Веб сценарии python это

Материал из Intuit

Перейти к: навигация, поиск

Разработка Web-приложений

Аннотация: Одна из главных сфер применения языка Python — web-приложения — представляется в этой лекции на конкретных примерах. Кроме того, делается акцент на типичных слабых местах безопасности web-приложений.

НЕТ ДАННЫХ

Под web-приложением будет пониматься программа, основной интерфейс пользователя которой работает в стандартном WWW-браузере под управлением HTML и XML-документов. Для улучшение качества интерфейса пользователя часто применяют JavaScript, однако это несколько снижает универсальность интерфейса. Следует заметить, что интерфейс можно построить на Java- или Flash-апплетах, однако, такие приложения сложно назвать web-приложениями, так как Java или Flash могут использовать собственные протоколы для общения с сервером, а не стандартный для WWW протокол HTTP.

При создании web-приложений стараются отделить Форму (внешний вид, стиль), Содержание и Логику обработки данных. Современные технологии построения web-сайтов дают возможность подойти достаточно близко к этому идеалу. Тем не менее, даже без применения многоуровневых приложений можно придерживаться стиля, позволяющего изменять любой из этих аспектов, не затрагивая (или почти не затрагивая) двух других. Рассуждения на эту тему будут продолжены в разделе, посвященном средам разработки.

CGI-сценарии

Классический путь создания приложений для WWW — написание CGI-сценариев (иногда говорят — скриптов). CGI (Common Gateway Interface, общий шлюзовой интерфейс) — это стандарт, регламентирующий взаимодействие сервера с внешними приложениями. В случае с WWW, web-сервер может направить запрос на генерацию страницы по определенному сценарию. Этот сценарий, получив на вход данные от web-сервера (тот, в свою очередь, мог получить их от пользователя), генерирует готовый объект (изображение, аудиоданные, таблицу стилей и т.п.).

При вызове сценария Web-сервер передает ему информацию через стандартный ввод, переменные окружения и, для ISINDEX, через аргументы командной строки (они доступны через sys.argv).

Два основных метода передачи данных из заполненной в браузере формы Web-серверу (и CGI-сценарию) — GET и POST. В зависимости от метода данные передаются по-разному. В первом случае они кодируются и помещаются прямо в URL, например: http://host/cgi-bin/a.cgi?a=1&b=3. Сценарий получает их в переменной окружения с именем QUERY_STRING. В случае метода POST они передаются на стандартный ввод.

Для корректной работы сценарии помещаются в предназначенный для этого каталог на web-сервере (обычно он называется cgi-bin) или, если это разрешено конфигурацией сервера, в любом месте среди документов HTML. Сценарий должен иметь признак исполняемости. В системе Unix его можно установить с помощью команды chmod a+x.

Следующий простейший сценарий выводит значения из словаря os.environ и позволяет увидеть, что же было ему передано:

Пример  
 
 #!/usr/bin/python
 
 import os
 print """Content-Type: text/plain
 
 %s""" % os.environ
 

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

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

Пример  
 
 QUERY_STRING
 

Строка запроса.

Пример  
 
 REMOTE_ADDR
 

IP-адрес клиента.

Пример  
 
 REMOTE_USER
 

Имя клиента (если он был идентифицирован).

Пример  
 
 SCRIPT_NAME
 

Имя сценария.

Пример  
 
 SCRIPT_FILENAME
 

Имя файла со сценарием.

Пример  
 
 SERVER_NAME
 

Имя сервера.

Пример  
 
 HTTP_USER_AGENT
 

Название броузера клиента.

Пример  
 
 REQUEST_URI
 

Строка запроса (URI).

Пример  
 
 HTTP_ACCEPT_LANGUAGE
 

Желательный язык документа.

Вот что может содержать словарь os.environ в CGI-сценарии:

Пример  
 
 {
 'DOCUMENT_ROOT': '/var/www/html', 
 'SERVER_ADDR': '127.0.0.1', 
 'SERVER_PORT': '80', 
 'GATEWAY_INTERFACE': 'CGI/1.1', 
 'HTTP_ACCEPT_LANGUAGE': 'en-us, en;q=0.50', 
 'REMOTE_ADDR': '127.0.0.1', 
 'SERVER_NAME': 'rnd.onego.ru',
 'HTTP_CONNECTION': 'close', 
 'HTTP_USER_AGENT': 'Mozilla/5.0 (X11; U; Linux i586; en-US; 
 rv:1.0.1) Gecko/20021003', 
 'HTTP_ACCEPT_CHARSET': 'ISO-8859-1, utf-8;q=0.66, *;q=0.66', 
 'HTTP_ACCEPT': 'text/xml,application/xml,application/xhtml+xml,
 text/html;q=0.9,text/plain;q=0.8,video/x-mng,image/png,image/jpeg,
 image/gif;q=0.2,text/css,*/*;q=0.1',
 'REQUEST_URI': '/cgi-bin/test.py?a=1', 
 'PATH': '/sbin:/usr/sbin:/bin:/usr/bin:/usr/X11R6/bin',
 'QUERY_STRING': 'a=1&b=2', 
 'SCRIPT_FILENAME': '/var/www/cgi-bin/test.py', 
 'HTTP_KEEP_ALIVE': '300', 
 'HTTP_HOST': 'localhost', 
 'REQUEST_METHOD': 'GET', 
 'SERVER_SIGNATURE': 'Apache/1.3.23 Server at rnd.onego.ru Port 80', 
 'SCRIPT_NAME': '/cgi-bin/test.py', 
 'SERVER_ADMIN': 'root@localhost', 
 'SERVER_SOFTWARE': 'Apache/1.3.23 (Unix)  (Red-Hat/Linux) 
 mod_python/2.7.8 Python/1.5.2 PHP/4.1.2',
 'SERVER_PROTOCOL': 'HTTP/1.0', 
 'REMOTE_PORT': '39251'
 }
 

Следующий CGI-сценарий выдает черный квадрат (в нем используется модуль Image для обработки изображений):

Пример  
 
 #!/usr/bin/python
 
 import sys
 print """Content-Type: image/jpeg
 """
 
 import Image
 i = Image.new("RGB", (10,10))
 i.im.draw_rectangle((0,0,10,10), 1)
 i.save(sys.stdout, "jpeg")
 

Модуль cgi

В Python имеется поддержка CGI в виде модуля cgi. Следующий пример показывает некоторые из его возможностей:

Пример  
 
 #!/usr/bin/python
 # -*- coding: cp1251 -*-
 import cgi, os
 
 # анализ запроса
 f = cgi.FieldStorage()
 if f.has_key("a"):
   a = f["a"].value
 else:
   a = "0"
 
 # обработка запроса
 b = str(int(a)+1)
 mytext = open(os.environ["SCRIPT_FILENAME"]).read()
 mytext_html = cgi.escape(mytext)
 
 # формирование ответа
 print """Content-Type: text/html
 
 <html><head><title>Решение примера: %(b)s = %(a)s + 1</title></head>
 <body>
 %(b)s
 <table width="80%%"><tr><td>
 <form action="me.cgi" method="GET">
 <input type="text" name="a" value="0" size="6">
 <input type="submit" name="b" value="Обработать">
 </form></td></tr></table>
 <pre>
 %(mytext_html)s
 </pre>
 </body></html>""" % vars()
 

В этом примере к заданному в форме числу прибавляется 1. Кроме того, выводится исходный код самого сценария. Следует заметить, что для экранирования символов >, <, & использована функция cgi.escape(). Для формирования Web-страницы применена операция форматирования. В качестве словаря для выполнения подстановок использован словарь vars() со всеми локальными переменными. Знаки процента пришлось удвоить, чтобы они не интерпретировались командой форматирования. Стоит обратить внимание на то, как получено значение от пользователя. Объект FieldStorage «почти» словарь, с тем исключением, что для получения обычного значения нужно дополнительно посмотреть атрибут value. Дело в том, что в сценарий могут передаваться не только текстовые значения, но и файлы, а также множественные значения с одним и тем же именем.

В примере выше проверка на допустимость произведена при вызове функции int(): если было бы задано нечисловое значение, сценарий аварийно завершился, а пользователь увидел Internal Server Error.

После анализа входных данных можно выделить фазу их обработки. В этой части CGI-сценария вычисляются переменные для дальнейшего вывода. Здесь необходимо учитывать не только значения переданных переменных, но и факт их присутствия или отсутствия, так как это тоже может влиять на логику сценария.

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

В приведенных примерах имена появлялись в строке запроса только один раз. Некоторые формы порождают несколько значений для одного имени. Получить все значения можно с помощью метода getlist():

Пример  
 
 lst = form.getlist("fld")
 

Список lst будет содержать столько значений, сколько полей с именем fld получено из web-формы (он может быть и пустым, если ни одно поле с заданным именем не было заполнено).

В некоторых случаях необходимо передать на сервер файлы (сделать upload). Следующий пример и комментарий к нему помогут разобраться с этой задачей:

Пример  
 
 #!/usr/bin/env python
 import cgi
 
 form = cgi.FieldStorage()
 file_contents = ""
 if form.has_key("filename"):
   fileitem = form["filename"]
   if fileitem.file:  
     file_contents = """<P>Содержимое переданного файла:
     <PRE>%s</PRE>""" % fileitem.file.read()
 
 print """Content-Type: text/html
 
 <HTML><HEAD><TITLE>Загрузка файла</TITLE></HEAD>
 <BODY><H1>Загрузка файла</H1>
 <P><FORM ENCTYPE="multipart/form-data" 
 ACTION="getfile.cgi" METHOD="POST">
 <br>Файл: <INPUT TYPE="file" NAME="filename">
 <br><INPUT TYPE="submit" NAME="button" VALUE="Передать файл">
 </FORM>
 %s
 </BODY></HTML>""" % file_contents
 

В начале следует рассмотреть web-форму, которая приведена в конце сценария: именно она будет выводиться пользователю при обращении по CGI-сценарию. Форма имеет поле типа file, которое в web-броузере представляется полоской ввода и кнопкой «Browse». Нажимая на кнопку «Browse», пользователь выбирает файл, доступный в ОС на его компьютере. После этого он может нажать кнопку «Передать файл» для передачи файла на сервер.

Для отладки CGI-сценария можно использовать модуль cgitb. При возникновении ошибки этот модуль выдаст красочную HTML-страницу с указанием места возбуждения исключения. В начале отлаживаемого сценария нужно поставить

Пример  
 
 import cgitb
 cgitb.enable(1)
 

Или, если не нужно показывать ошибки в браузере:

Пример  
 
   import cgitb
   cgitb.enable(0, logdir="/tmp")
 

Только необходимо помнить, что следует убрать эти строки, когда сценарий будет отлажен, так как он выдает кусочки кода сценария. Это может быть использовано злоумышленниками, с тем чтобы найти уязвимости в CGI-сценарии или подсмотреть пароли (если таковые присутствуют в сценарии).

Что после CGI?

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

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

Такие технологии существуют и обычно опираются на модули, встраиваемые в web-сервер.

Для ускорения работы CGI используются различные схемы, например, FastCGI или PCGI (Persistent CGI). В данной лекции предлагается к рассмотрению специальным модуль для web-сервера Apache, называемый mod_python.

Пусть модуль установлен на web-сервере в соответствии с инструкциями, данными в его документации.

Модуль mod_python позволяет сценарию-обработчику вклиниваться в процесс обработки HTTP-запроса сервером Apache на любом этапе, для чего сценарий должен иметь определенным образом названные функции.

Сначала нужно выделить каталог, в котором будет работать сценарий-обработчик. Пусть это каталог /var/www/html/mywebdir. Для того чтобы web-сервер знал, что в этом каталоге необходимо применять mod_python, следует добавить в файл конфигурации Apache следующие строки:

Пример  
 
 <Directory "/var/www/html/mywebdir">
   AddHandler python-program .py
   PythonHandler mprocess
 </Directory>
 

После этого необходимо перезапустить web-сервер и, если все прошло без ошибок, можно приступать к написанию обработчика mprocess.py. Этот сценарий будет реагировать на любой запрос вида http://localhost/*.py.

Следующий сценарий mprocess.py выведет в браузере страницу со словами Hello, world!:

Пример  
 
 from mod_python import apache
 
 def handler(req):
   req.content_type = "text/html"
   req.send_http_header()
   req.write("""<HTML><HEAD><TITLE>Hello, world!</TITLE></HEAD>
   <BODY>Hello, world!</BODY></HTML>""")
   return apache.OK
 

Отличия сценария-обработчика от CGI-сценария:

• Сценарий-обработчик не запускается при каждом HTTP-запросе: он уже находится в памяти, и из него вызываются необходимые функции-обработчики (в приведенном примере такая функция всего одна — handler()). Каждый процесс-потомок web-сервера может иметь свою копию сценария и интерпретатора Python.
• Как следствие п.1 различные HTTP-запросы делят одни и те же глобальные переменные. Например, таким образом можно инициализировать соединение с базой данных и применять его во всех запросах (хотя в некоторых случаях потребуются блокировки, исключающие одновременное использование соединения разными потоками (нитями) управления).
• Обработчик задействуется при обращении к любому «файлу» с расширением py, тогда как CGI-сценарий обычно запускается при обращении по конкретному имени.
• В сценарии-обработчике нельзя рассчитывать на то, что он увидит модули, расположенные в том же каталоге. Возможно, придется добавить некоторые каталоги в sys.path.
• Текущий рабочий каталог (его можно узнать с помощью функции os.getcwd()) также не находится в одном каталоге с обработчиком.
• #!-строка в первой строке сценария не определяет версию интерпретатора Python. Работает версия, для которой был скомпилирован mod_python.
• Все необходимые параметры передаются в обработчик в виде Request-объекта. Возвращаемые значения также передаются через этот объект.
• Web-сервер замечает, что сценарий-обработчик изменился, но не заметит изменений в импортируемых в него модулях. Команда touchmprocess.py обновит дату изменения файла сценария.
• Отображение os.environ в обработчике может быть обрезанным. Кроме того, вызываемые из сценария-обработчика другие программы его не наследуют, как это происходит при работе с CGI-сценариями. Переменные можно получить другим путем: req.add_common_vars(); params = req.subprocess_env.
• Так как сценарий-обработчик не является «одноразовым», как CGI-сценарий, из-за ошибок программирования (как самого сценария, так и других компонентов) могут возникать утечки памяти (программа не освобождает ставшую ненужной память). Следует установить значение параметра MaxRequestsPerChild (максимальное число запросов, обрабатываемое одним процессом-потомком) больше нуля.

Другой возможный обработчик — сценарий идентификации:

Пример  
 
 def authenhandler(req):
   password = req.get_basic_auth_pw()
   user = req.connection.user
   if user == "user1" and password == "secret":
       return apache.OK
   else:
       return apache.HTTP_UNAUTHORIZED
 

Эту функцию следует добавить в модуль mprocess.py, который был рассмотрен ранее. Кроме того, нужно дополнить конфигурацию, назначив обработчик для запросов идентификации (PythonAuthenHandler), а также обычные для Apache директивы AuthType, AuthName, require, определяющие способ авторизации:

Пример  
 
 <Directory "/var/www/html/mywebdir">
   AddHandler python-program .py
   PythonHandler mprocess
   PythonAuthenHandler mprocess
   AuthType Basic
   AuthName "My page"
   require valid-user
 </Directory>
 

Разумеется, это — всего лишь пример. В реальности идентификация может быть устроена намного сложнее.

Другие возможные обработчики (по документации к mod_python можно уточнить, в какие моменты обработки запроса они вызываются):

Пример  
 
 PythonPostReadRequestHandler
 

Обработка полученного запроса сразу после его получения.

Пример  
 
 PythonTransHandler
 

Позволяет изменить URI запроса (в том числе имя виртуального сервера).

Пример  
 
 PythonHeaderParserHandler
 

Обработка полей запроса.

Пример  
 
 PythonAccessHandler
 

Обработка ограничений доступа (например, по IP-адресу).

Пример  
 
 PythonAuthenHandler
 

Идентификация пользователя.

Пример  
 
 PythonTypeHandler
 

Определение и/или настройка типа документа, языка и т.д.

Пример  
 
 PythonFixupHandler
 

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

Пример  
 
 PythonHandler
 

Основной обработчик запроса.

Пример  
 
 PythonInitHandler
 

PythonPostReadRequestHandler или PythonHeaderParserHandler в зависимости от нахождения в конфигурации web-сервера.

Пример  
 
 PythonLogHandler
 

Управление записью в логи.

Пример  
 
 PythonCleanupHandler
 

Обработчик, вызываемый непосредственно перед уничтожением Request-объекта.

Некоторые из этих обработчиков работают только глобально, так как при вызове даже каталог их приложения может быть неизвестен (таков, например, PythonPostReadRequestHandler).

С помощью mod_python можно строить web-сайты с динамическим содержимым и контролировать некоторые аспекты работы web-сервера Apache через Python-сценарии.

Среды разработки

Для создания Web-приложений применяются и более сложные средства, чем web-сервер с расположенными на нем статическими документами и CGI-сценариями. В зависимости от назначения такие программные системы называются серверами web-приложений, системами управления содержимым (CMS, Content Management System), системы web-публикации и средствами для создания WWW-порталов. Причем CMS-система может быть выполнена как web-приложение, а средства для создания порталов могут базироваться на системах web-публикации, для которых CMS-система является подсистемой. Поэтому, выбирая систему для конкретных нужд, стоит уточнить, какие функции она должна выполнять.

Язык Python, хотя и уступает PHP по количеству созданных на нем web-систем, имеет несколько достаточно популярных приложений. Самым ярким примером средства для создания сервера web-приложений является Zope (произносится «зоп») (см. [1]) (Z Object Publishing Environment, среда публикации объектов). Zope имеет встроенный web-сервер, но может работать и с другими Web-серверами, например, Apache. На основе Zope можно строить web-порталы, например, с помощью Plone/Zope, но можно разрабатывать и собственные web-приложения. При этом Zope позволяет разделить Форму, Содержание и Логику до такой степени, что Содержанием могут заниматься одни люди (менеджеры по содержимому), Формой — другие (web-дизайнеры), а Логикой — третьи (программисты). В случае с Zope Логику можно задать с помощью языка Python (или, как вариант, Perl), Форма может быть создана в графических или специализированных web-редакторах, а работа с содержимым организована через Web-формы самого Zope.

Zope и его объектная модель

В рамках этой лекции невозможно детально рассмотреть такой инструмент как Zope, поэтому стоит лишь заметить, что он достаточно интересен не только в качестве среды разработки web-приложений, но и с точки зрения подходов. Например, уникальная объектно-ориентированная модель Zope позволяет довольно гибко описывать требуемое приложение.

Zope включает в себя следующие возможности:

• Web-сервер. Zope может работать с Web-серверами через CGI или использовать свой встроенный Web-сервер (ZServer).
• Среда разработчика выполнена как Web-приложение. Zope позволяет создавать Web-приложения через Web-интерфейс.
• Поддержка сценариев. Zope поддерживает несколько языков сценариев: Python, Perl и собственный DTML (Document Template Markup Language, язык разметки шаблона документа).
• База данных объектов. Zope использует в своей работе устойчивые объекты, хранимые в специальной базе данных (ZODB). Имеется достаточно простой интерфейс для управления этой базой данных.
• Интеграция с реляционными базами данных. Zope может хранить свои объекты и другие данные в реляционных СУБД: Oracle, PostgreSQL, MySQL, Sybase и т.п.

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

Разработчики Zope исходили из лежащей в основе WWW объектной модели, в которой загрузку документа по URI можно сравнить с отправкой сообщения объекту. Объекты Zope разложены по папкам (folders), к которым привязаны политики доступа для пользователей, имеющих определенные роли. В качестве объектов могут выступать документы, изображения, мультимедиа-файлы, адаптеры к базам данных и т.п.

Документы Zope можно писать на языке DTML — дополнении HTML с синтаксисом для включения значений подобно SSI (Server-Side Include). Например, для вставки переменной с названием документа можно использовать

Пример  
 
 <!- #var document_title ->
 

Следует заметить, что объекты Zope могут иметь свои атрибуты, а также методы, в частности, написанные на языке Python. Переменные же могут появляться как из заданных пользователем значений, так и из других источников данных (например, из базы данных посредством выполнения выборки функцией SELECT).

Сейчас для описания документа Zope все чаще применяется ZPT (Zope Page Templates, шаблоны страниц Zope), которые в свою очередь используют TAL (Template Attribute Language, язык шаблонных атрибутов). Он позволяет заменять, повторять или пропускать элементы документа описываемого шаблоном документа. «Операторами» языка TAL являются XML-атрибуты из пространства имен TAL. Пространство имен сегодня описывается следующим идентификатором:

Пример  
 
 xmlns:tal="http://xml.zope.org/namespaces/tal"
 

Оператор TAL имеет имя и значение (что выражается именем и значением атрибута). Внутри значения обычно записано TAL-выражение, синтаксис которого описывается другим языком — TALES (Template Attribute Language Expression Syntax, синтаксис выражений TAL).

Таким образом, ZPT наполняет содержимым шаблоны, интерпретируя атрибуты TAL. Например, чтобы Zope подставил название документа (тег TITLE), шаблон может иметь следующий код:

Пример  
 
 <title tal:content="here/title">Doc Title</title>
 

Стоит заметить, что приведенный код сойдет за код на HTML, то есть, Web-дизайнер может на любом этапе работы над проектом редактировать шаблон в HTML-редакторе (при условии, что тот сохраняет незнакомые атрибуты из пространства имен tal). В этом примере here/titleявляется выражением TALES. Текст Doc Title служит ориентиром для web-дизайнера и заменяется значением выражения here/title, то есть, будет взято свойство title документа Zope.

В качестве более сложного примера можно рассмотреть организацию повтора внутри шаблона (для опробования этого примера в Zope нужно добавить объект Page Template):

Пример  
 
 <ul>
    <li tal:define="s modules/string" 
        tal:repeat="el python:s.digits"> 
    <a href="DUMMY"
       tal:attributes="href string:/digit/$el"
       tal:content="el">SELECTION</a>
   </li> 
 </ul>
 

Этот шаблон породит следующий результат:

Пример  
 
 <ul>
    <li><a href="/digit/0">0</a></li>
    <li><a href="/digit/1">1</a></li>
    <li><a href="/digit/2">2</a></li>
    <li><a href="/digit/3">3</a></li>
    <li><a href="/digit/4">4</a></li>
    <li><a href="/digit/5">5</a></li>
    <li><a href="/digit/6">6</a></li>
    <li><a href="/digit/7">7</a></li>
    <li><a href="/digit/8">8</a></li>
    <li><a href="/digit/9">9</a></li>
 </ul>
 

Здесь нужно обратить внимание на два основных момента:

• в шаблоне можно использовать выражения Python (в данном примере переменная s определена как модуль Python) и переменную-счетчик цикла el, которая проходит итерации по строке string.digits.
• с помощью TAL можно задавать не только содержимое элемента, но и атрибута тега (в данном примере использовался атрибут href).

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

Любой программист знает, что программирование тем эффективнее, чем лучше удалось «расставить скобки», выведя «общий множитель за скобки». Другими словами, хорошие программисты должны быть достаточно «ленивы», чтобы найти оптимальную декомпозицию решаемой задачи. При проектировании динамического web-сайта Zope позволяет разместить «множители» и «скобки» так, чтобы достигнуть максимального повторного использования кода (как разметки, так и сценариев). Помогает этому уникальный подход к построению взаимоотношений между объектами: заимствование (acquisition).

Пусть некоторый объект (документ, изображение, сценарий, подключение к базе данных и т.п.) расположен в папке Example. Теперь объекты этой папки доступны по имени из любых нижележащих папок. Даже политики безопасности заимствуются более глубоко вложенными папками от папок, которые ближе к корню. Заимствование является очень важной концепцией Zope, без понимания которой Zope сложно грамотно применять, и наоборот, ее понимание позволяет экономить силы и время, повторно используя объекты в разработке.

Самое интересное, что заимствовать объекты можно также из параллельных папок. Пусть, например, рядом с папкой Example находится папка Zigzag, в которой лежит нужный объект (его наименование note). При этом в папке Example программиста интересует объект index_html, внутри которого вызывается note. Обычный путь к объекту index_html будет происходить по URI вроде http://zopeserver/Example/. А вот если нужно использовать note из Zigzag (и в папке Example его нет), то URI будет: http://zopeserver/Zigzag/Example/. Таким образом, указание пути в Zope отличается от традиционного пути, скажем, в Unix: в пути могут присутствовать «зигзаги» через параллельные папки, дающие возможность заимствовать объекты из этих папок. Таким образом, можно сделать конкретную страницу, комбинируя один или несколько независимых аспектов.

Заключение

В этой лекции были рассмотрены различные подходы к использованию Python в web-приложениях. Самый простой способ реализации web-приложения — использование CGI-сценариев. Более сложным является использование специальных модулей для web-сервера, таких как mod_python. Наконец, существуют технологии вроде Zope, которые предоставляют специализированные сервисы, позволяющие создавать web-приложения.

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Deploy Your Python Script on the Web With Flask

You wrote a Python script that you’re proud of, and now you want to show it off to the world. But how? Most people won’t know what to do with your .py file. Converting your script into a Python web application is a great solution to make your code usable for a broad audience.

In this tutorial, you’ll learn how to go from a local Python script to a fully deployed Flask web application that you can share with the world.

By the end of this tutorial, you’ll know:

• What web applications are and how you can host them online
• How to convert a Python script into a Flask web application
• How to improve user experience by adding HTML to your Python code
• How to deploy your Python web application to Google App Engine

In addition to walking through an example project, you’ll find a number of exercises throughout the tutorial. They’ll give you a chance to solidify what you’re learning through extra practice. You can also download the source code that you’ll use to build your web application by clicking the link below:

$ python3 -m pip install <your-package-name>

app-engine-python 1.9.91
bq 2.0.62
cloud-datastore-emulator 2.1.0
core 2020.11.13
gsutil 4.55

 1from flask import Flask
 2
 3app = Flask(__name__)
 4
 5@app.route("/")
 6def index():
 7    return "Congratulations, it's a web app!"

$ source venv/bin/activate

$ python3 -m pip install -r requirements.txt

if __name__ == "__main__":
    app.run(host="127.0.0.1", port=8080, debug=True)

 * Serving Flask app "main" (lazy loading)
 * Environment: production
   WARNING: This is a development server.
   Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: on
 * Running on http://127.0.0.1:8080/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 315-059-987

ERROR: (gcloud.app.deploy)
You do not currently have an active account selected.
Please run:

  $ gcloud auth login

to obtain new credentials.

If you have already logged in with a different account:

    $ gcloud config set account ACCOUNT

to select an already authenticated account to use.

Your browser has been opened to visit:

    https://accounts.google.com/o/oauth2/auth?client_id=<yourid>

You are now logged in as [<your@email.com>].
Your current project is [None].  You can change this setting by running:
  $ gcloud config set project PROJECT_ID

$ gcloud config set project hello-app-295110

You are creating an app for project [hello-app-295110].
WARNING: Creating an App Engine application for a project is
irreversible and the region cannot be changed.
More information about regions is at
<https://cloud.google.com/appengine/docs/locations>.

Please choose the region where you want your App Engine application
located:

 [1] asia-east2
 [2] asia-northeast1
 [3] asia-northeast2
 [4] asia-northeast3
 [5] asia-south1
 [6] asia-southeast2
 [7] australia-southeast1
 [8] europe-west
 [9] europe-west2
 [10] europe-west3
 [11] europe-west6
 [12] northamerica-northeast1
 [13] southamerica-east1
 [14] us-central
 [15] us-east1
 [16] us-east4
 [17] us-west2
 [18] us-west3
 [19] us-west4
 [20] cancel
Please enter your numeric choice:

Creating App Engine application in project [hello-app-295110]
and region [europe-west]....done.
Services to deploy:

descriptor:      [/Users/realpython/Documents/helloapp/app.yaml]
source:          [/Users/realpython/Documents/helloapp]
target project:  [hello-app-295110]
target service:  [default]
target version:  [20201109t112408]
target url:      [https://hello-app-295110.ew.r.appspot.com]


Do you want to continue (Y/n)?

Beginning deployment of service [default]...
Created .gcloudignore file. See `gcloud topic gcloudignore` for details.
╔════════════════════════════════════════════════════════════╗
╠═ Uploading 3 files to Google Cloud Storage                ═╣
╚════════════════════════════════════════════════════════════╝
File upload done.
Updating service [default]...⠼

Deployed service [default] to [https://hello-app-295110.ew.r.appspot.com]

You can stream logs from the command line by running:
  $ gcloud app logs tail -s default

To view your application in the web browser run:
  $ gcloud app browse

def fahrenheit_from(celsius):
    """Convert Celsius to Fahrenheit degrees."""
    try:
        fahrenheit = float(celsius) * 9 / 5 + 32
        fahrenheit = round(fahrenheit, 3)  # Round to three decimal places
        return str(fahrenheit)
    except ValueError:
        return "invalid input"

if __name__ == "__main__":
    celsius = input("Celsius: ")
    print("Fahrenheit:", fahrenheit_from(celsius))

from flask import Flask

app = Flask(__name__)

@app.route("/")
def index():
    return "Congratulations, it's a web app!"

@app.route("/")
def fahrenheit_from(celsius):
    """Convert Celsius to Fahrenheit degrees."""
    try:
        fahrenheit = float(celsius) * 9 / 5 + 32
        fahrenheit = round(fahrenheit, 3)  # Round to three decimal places
        return str(fahrenheit)
    except ValueError:
        return "invalid input"

if __name__ == "__main__":
    app.run(host="127.0.0.1", port=8080, debug=True)

@app.route("/<celsius>")
def fahrenheit_from(celsius):
    # -- snip --

@app.route("/<int:celsius>")

from flask import Flask

app = Flask(__name__)

@app.route("/")
def index():
    return "Congratulations, it's a web app!"

@app.route("/<int:celsius>")
def fahrenheit_from(celsius):
    """Convert Celsius to Fahrenheit degrees."""
    fahrenheit = float(celsius) * 9 / 5 + 32
    fahrenheit = round(fahrenheit, 3)  # Round to three decimal places
    return str(fahrenheit)

if __name__ == "__main__":
    app.run(host="127.0.0.1", port=8080, debug=True)

@app.route("/")
def index():
    return """<form action="" method="get">
                <input type="text" name="celsius">
                <input type="submit" value="Convert">
              </form>"""

<form action="" method="get">
  <input type="text" name="celsius" />
  <input type="submit" value="Convert" />
</form>

<form action="" method="get">
  <input type="text" name="celsius" />
  <input type="submit" value="Convert" />
</form>

<form action="" method="get">
  <input type="text" name="celsius" />
  <input type="submit" value="Convert" />
</form>

from flask import Flask
from flask import request

app = Flask(__name__)

@app.route("/")
def index():
    celsius = request.args.get("celsius", "")
    return (
        """<form action="" method="get">
                <input type="text" name="celsius">
                <input type="submit" value="Convert">
            </form>"""
        + celsius
    )

@app.route("/<int:celsius>")
def fahrenheit_from(celsius):
    """Convert Celsius to Fahrenheit degrees."""
    fahrenheit = float(celsius) * 9 / 5 + 32
    fahrenheit = round(fahrenheit, 3)  # Round to three decimal places
    return str(fahrenheit)

if __name__ == "__main__":
    app.run(host="127.0.0.1", port=8080, debug=True)

<marquee><a href="https://www.realpython.com">CLICK ME</a></marquee>

from flask import Flask
from flask import request, escape

app = Flask(__name__)

@app.route("/")
def index():
    celsius = str(escape(request.args.get("celsius", "")))
    return (
        """<form action="" method="get">
                <input type="text" name="celsius">
                <input type="submit" value="Convert">
            </form>"""
        + celsius
    )

@app.route("/<int:celsius>")
def fahrenheit_from(celsius):
    """Convert Celsius to Fahrenheit degrees."""
    fahrenheit = float(celsius) * 9 / 5 + 32
    fahrenheit = round(fahrenheit, 3)  # Round to three decimal places
    return str(fahrenheit)

if __name__ == "__main__":
    app.run(host="127.0.0.1", port=8080, debug=True)

 1from flask import Flask
 2from flask import request
 3
 4app = Flask(__name__)
 5
 6@app.route("/")
 7def index():
 8    celsius = request.args.get("celsius", "")
 9    if celsius:
10        fahrenheit = fahrenheit_from(celsius)
11    else:
12        fahrenheit = ""
13    return (
14        """<form action="" method="get">
15                Celsius temperature: <input type="text" name="celsius">
16                <input type="submit" value="Convert to Fahrenheit">
17            </form>"""
18        + "Fahrenheit: "
19        + fahrenheit
20    )
21
22def fahrenheit_from(celsius):
23    """Convert Celsius to Fahrenheit degrees."""
24    try:
25        fahrenheit = float(celsius) * 9 / 5 + 32
26        fahrenheit = round(fahrenheit, 3)  # Round to three decimal places
27        return str(fahrenheit)
28    except ValueError:
29        return "invalid input"
30
31if __name__ == "__main__":
32    app.run(host="127.0.0.1", port=8080, debug=True)

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Deploy Your Python Script on the Web With Flask

Мы живём в золотой век web-разработки, имея в своём распоряжении гибкие веб-технологии и массу полезных инструментов и интерфейсов, позволяющих реализовывать замыслы практически любой сложности. И язык программирования Python — один из них.

Python и web

Популярность Питона в веб-разработке подтверждается, к примеру, простым взглядом на рейтинг портала HotFrameworks.com. Там можно увидеть, что один из самых популярных фреймворков для создания веб-приложений предназначен именно для Пайтона (разумеется, речь идёт о Django, который на момент написания материала находился на 6 месте).

Говоря о вебе, скажем, что Python применяется для обработки бэкенда и маршрутизации, где еще в роли конкурентов выступают PHP и Ruby. Ну а web-страницы всё равно следует отображать посредством HTML/CSS, причём функциональная часть фронтенда, как и прежде, реализуется на JavaScript.

Таким образом, без взаимодействия разных технологий и интерфейсов (interface) не обойтись. Но это не проблема, ведь Python-фреймворки позволяют существенно упрощать это взаимодействие. Тот же Django включает в себя систему шаблонов, обеспечивающих написание специальных HTML-файлов, которые могут вставлять Python-код, взаимодействуя с данными из бэкенда. Этот тип взаимодействия принято называть Full Stack-фреймворком. С его помощью вы сможете работать с шаблонами web-страниц, запросами маршрутизации, хранилищами баз данных, системами, обрабатывающими HTTP-запросы, и т. д.

Но существуют и не Full Stack-фреймворки, а так называемые микрофреймворки, обрабатывающие лишь базовую логику. Они более гибкие, изучаются в кратчайшие сроки, но потребуют от вас каждый раз изобретать велосипед, ведь для сторонних работ их придётся объединять с шаблонизаторами, сторонними БД и прочее.

Пайтон и другие языки

Может возникнуть закономерный, но риторический вопрос: «Если я использую JavaScript для внешнего интерфейса, почему я не могу применять тот же JavaScript для бэкенда?» И это действительно так, но то же самое можно сказать и про PHP, ведь язык востребован, существует десятилетиями и имеет большое количество технической документации. Следовательно, для бэкенда прекрасно подходит и PHP.

Вывод прост: большинство задач при разработке веба вы сможете решить с применением любого языка. По-настоящему важно лишь то, насколько удобно вам это делать на выбранном языке. Таким образом, если вы предпочитаете Питон, зачем от него отказываться и тратить время на изучение чего-нибудь другого? Сегодня использование этого языка для веба обычное явление (it’s common).

Frameworks

Мы уже говорили о том, что веб-разработка на Python предполагает использование специальных фреймворков. Их много, и каждый по-своему хорош. Обычно проблем с документацией, сообществами и официальной поддержкой не возникает.

Наиболее известны фреймворки Django и Flask. Мы уже о них писали, поэтому повторяться не будем. Разве что, упомянем такой фреймворк, как Pyramid — некий компромиссе между Flask и Django. Да, Pyramid не настолько функционален, но удобен и прост, плюс имеет достаточно средств для организации большинства web-приложений. Также он имеет широкую библиотеку как официальных, так и неофициальных плагинов, используя которые, вы успешно реализуете необходимые замыслы.

Python и real life

А как быть с реальным применением для написания веба? Тут всё очень неплохо, достаточно вспомнить лишь следующие проекты, реализованные посредством Python. Просто загибайте пальцы:
— YouTube,
— Google,
— Reddit,
— Instagram,
— DropBox,
— FireFox,
— Pinterest и многие другие.

Да, в некоторых проектах Python применяется лишь частично, но его влияние на web всё же велико.

CGI: исполнение простейшего скрипта

Создавать динамические страницы на Питоне можно посредством скриптов CGI. Скрипты CGI представляют собой исполняемые файлы — они выполняются web-сервером, если в URL запрашивается соответствующий скрипт. В этой части статьи мы расскажем про то, как запустить скрипт на локальном сервере и вывести на экран простейшие данные, к примеру, Hello world,.

Настраиваем локальный сервер

В «Пайтон» CGI-сервер уже встроен, поэтому настроить его несложно. Команда ниже позволит запустить его из консоли (если у вас Linux). Причем запускать команду следует из папки, в которой желаем работать:

Если у вас операционная система Windows, запуск Python-файла будет еще проще. Важно, чтобы файл находился в той же папке, в которой планируется работа:

Следующее, что нужно сделать, — открыть браузер и набрать в адресной строке localhost:8000.

Итог должен быть приблизительно следующим:

Hello world

Далее в папке, где запускался сервер, следует создать папку cgi-bin. Потом следует создать скрипт hello.py, куда будут включены следующие данные:

Первая строка свидетельствует, что это Python-скрипт, вторая печатает заголовок, который значит, что это будет html-файл (веб-браузер различает файлы по заголовкам). Третья строка отделяет заголовки от тела ответа, четвертая — печатает «Hello world».

Останется перейти на localhost:8000/cgi-bin/hello.py, чтобы убедиться, что выводятся данные «Hello world».

Если по каким-то причинам что-то не работает, проверьте, правильно ли выставлены права на выполнение.

Когда мы говорим о вебе, вышеописанные действия — лишь начало пути. Если хотите двигаться дальше, надо будет:
1) позаботиться об обработке данных и cookies;
2) для обеспечения возможности работы с пользовательскими данными, эти данные надо будет где-либо хранить. Проще всего — хранить данные в файлах (но это не самое практичное и безопасное решение). Лучший способ — хранение данных в базе данных;
3) и вот только после этого можно будет приступить к публикации простейшего приложения в интернете. То есть речь идет о запуске cgi на виртуальном сервере, а не локальном.

Обучение

Может появиться вопрос: «Где научиться Python именно в контексте веб-разработки?» Что же, у нас есть на него ответ. В OTUS уже не первый год существует курс, посвящённый именно этому направлению в программировании. Однако никто не мешает вам освоить и общий курс продвинутой разработки на Python. Или даже овладеть профессией с нуля, изучив «Подготовительный курс по Python-разработке». Выбор за вами!

Источники:
• http://www.makeuseof.com/tag/python-web-development-build/;
• https://pythonworld.ru/web.

Одна из няшних самых горячих тем сегодня — это «веб-приложения.» В отличие от традиционного «исполнимого» программного обеспечения, которое выполняется в определенном месте на настольном компьютере, веб приложение выполняется на централизованном сервере и предоставляет его возможности через Интернет, обычно через протокол HTTP и обычный веб-браузер. Веб приложения все более и более популярны, потому что они могут быть легоко доступны — просто введите URL в браузер — и приложение доступно одновременно целому ряду пользователей. Некоторые веб приложения обеспечивают электронную коммерцию (eBay), некоторые служат для развлечений (как например Yahoo! Games), и другие, как например Salesforce.com, управляют информацией предприятия.
В то время как Java, Perl, и PHP часто восхваляются как идеальные языки программирования для разработки веб приложений, возможности Python в этой области такие же. Действительно, Python отлично для создания динамического содержимого веб страниц.
Самый простой путь создания веб приложение на Python — использовать Common Gateway Interface (CGI). CGI — это протокол, который описывает, как соединить клиентов с веб приложениями.
Обычно, когда вы запрашиваете статическую страницу у веб-сервера, он находит файл, что вы запросили и посылает файл обратно в ответ. Например, запрос на http://www.example.com/contact.html возвращает страницу HTML contact.html. Однако, если запрос ссылается на сценарий CGI, то вместо возвращения сценария (его кода как содержимого), сценарий запускается и результат работы сценария присылается в ответ. Сценарии CGI генерируют содержимое динамически в ответ на запрос (и его параметры, как вы вскоре увидите).
Однажды поняв, как работает CGI, создание динамического содержимого становится простым использованием команды print. И в противоположность его репутации, CGI не обязательно медленен. Даже если интерпретатор Python запускается для каждого вызова сценария, рекомендуется попробовать CGI перед выбором более сложной веб структуры приложения.
Углубимся в программирование CGI на Python. Первая из двух частей объясняет основы CGI, описывает, как посылаются формы HTML и объясняет, как обработать введенные в форму данные.
Весь код в этой статье должен работать в Python 2.2 и более поздних версиях

Заголовки и концы строк
Половина работы при написания веб приложения — это возвращение правильных заголовков в ответ на запрос. Пересылка действительных заголовков важна не только для информации, которую получает клиент — если ваша программа не выдает действительных заголовков, веб-сервер предполагает, что ваш сценарий выполнился неуспешно и показывает устрашащую Ошибку 500… Внутренняя Ошибка Сервера.
Есть уйма различных заголовков, которые вы можете послать. Как минимум вы должны послать заголовок (фактически, во многих ситуациях это, возможно, является единственным заголовкмв, который вам нужно послать) Content-Type и вы должны завершить ваш список заголовков пустой линией.
Все заголовки выглядят как «тип_заголовка: имя_заголовока-значениеrn». Однако, большинство клиентов и серверов позволяют лишь n, то есть то, что вы получите в качестве нормального завершения строки на системах типа UNIX.
Hello World
Составим обязательную для новичков программу «Hello, World» как CGI скрипт:

#!/usr/bin/python
import sys
try:
    import cgitb
    cgitb.enable()
except ImportError:
    sys.stderr = sys.stdout

def cgiprint(inline=''):
    sys.stdout.write(inline)
    sys.stdout.write('rn')
    sys.stdout.flush()           

contentheader = 'Content-Type: text/html'

thepage = '''< html>< head>

< title>%s< /title>
< /head>< body>
%s
< /body>< /html>

'''
h1 = '< h1>%s< /h1>'

if __name__ == '__main__':
    cgiprint(contentheader)   # заголовок содержимого
    cgiprint()                       # завершить заголовки пустой строкой

    title = 'Hello World'
    headline = h1 % 'Hello World'

    print thepage % (title, headline)

Давайте пройдемся по коду.
Если вы запускаете сценарий CGI на системе Linux или Unix, вы должны включать обязательную линию (#!/usr/bin/python) «shebang» в строке 1, чтобы сказать сценарию, где найти Python.
Следующая часть сценария — это try/except блок, который пытается импортировать модуль cgitb. Обычно ошибки в программе на Python посылаются в sys.stderr. Однако, когда запускается CGI скрипт, sys.stderr транслирует в журнал регистрации ошибок сервера. Но постоянный поиск ошибок в журнале регистрации ошибок — это неудобно при отлаживании. Вместо этого cgitb выводит сообщения об ошибках, в том числе полезную информацию подобно значениям переменных, в браузер. (Этот модуль был только введен в Python 2.2.) Если импорт не удается, stderr присоединяется к stdout, который делает подобную, но не такую эффективную работу. (Не используйте модуль cgitb в производственных приложениях. Показываемая им информация включает детали о вашей системе, которая, возможно, полезна для возможного взломщика.)
Потом, cgiprint() выпускает две строки заголовков и должным образом завершает заголовки правильными окончаниями строк. (cgiprint() должна использоваться только для строк заголовков.) cgiprint() посылает заголовок Content-Type. Поскольку сценарий возвращает веб-страницу (которая является формой текста) тип/подтип заголовка — это text/html. Посылается только один заголовок, затем заголовки завершаются пустой строкой.
cgiprint() сбрасывает буфер выходного потока, используя sys.stdout.flush(). Большинство серверов буферизует выдачу сценариев, пока сценарий не завершен. Для сценариев, которые долго выполняются, буферизация выхода, возможно, расстроит вашего пользователя. Вы можете или регулярно сбрасывать ваш буфер, или запускать Python в небуферизованном режиме. Вариант командной строки: -u, который вы можете вставить как #!/usr/bin/python -u.
В конце концов, сценарий посылает маленькую страницу HTML, которая должна выглядеть знакомо, если вы использовали HTML до этого момента.
Пользовательский интерфейс и формы HTML
При написании CGI скриптов, ваш интерфейс пользователя — это веб-браузер. Объединеняя Javascript, Динамический HTML (DHTML) и HTML формы, вы можете создавать богатые возможностями веб приложения.
Основными элементами HTML, используемыми для общения с CGI скриптами, являются формы и элементы формы для пользовательского ввода, в том числе текстовые поля, радиокнопки, переключатели, меню и так далее.
Пример формы
Типичная, простая форма HTML, возможно, кодировалась бы подобно этому:

< form action="/cgi-bin/formprocessor.py" method="get">
  What is Your Name : < input name="param1"
    type="text" value="Joe Bloggs" />< br />
  < input name="param2" type="radio" value="this"
    checked="checked" /> Select This< br />

  < input name="param2" type="radio"  value="that" />or That< br />

  < input name="param3" type="checkbox" checked="checked" />
    Check This< br />
  < input name="param4" type="checkbox"  checked="checked" />
    and This Too ?< br />

  < input name="hiddenparam" type="hidden" value="some_value" />

  < input type="reset"  />

  < input type="submit" />
< /form>

Когда пользователь нажимает кнопку Submit, данные из полей формы включается в запрос HTTP. Внутри тега form есть два параметра, которые определяют то, как происходит включение. Параметр action — это URI вашего сценария CGI, то есть куда направляется запрос. Параметр method конкретизирует, как значения кодируются в запросе. Два возможных метода — GET и POST.
Более простой — GET. При использовании GET значения формы кодируются, чтобы быть «URL безопасными» и добавляются в конец URL как список параметров. С POST кодируемые значения посылаются в теле запроса после того, как заголовки посланы.
GET проще, однако длина URL ограничена. Таким образом, использование GET навязывает максимальный ограничение для формы, которая может быть послана. (Около 1,000 символов — это ограничение многих серверов.) Если вы используете форму, чтобы получить длинный текстовый ввод из вашей формы, используйте POST. POST более подходит для запросов, где посылается больше данных.
Одно преимущество GET — то, что вы можете закодировать параметры для скрипта в нормальную ссылку HTML. Это означает, что параметры могут быть отправлены вашей программе без нажатия кнопки пользователем. Кодируемый набор значений выглядит примерно так:

param1=value1&param2=value+2&param3=value%263(Http GET запрос добавляет эту строку к URL.) Так что, целый URL, возможно, стал бы чем-нибудь вроде http://www.someserver.com/cgi-bin/test.py?param1=value1&param2=value+2&param3=value%26.
? отделяет URI вашего сценария от кодируемых параметров. Символы & отделяют параметры друг от друга. + представляет пространство (которое не нужно посылать как часть URI, конечно), и %26 — это кодируемое значение, которое представляет &. & не нужно посылать как часть значения, иначе CGI думал бы, что был послан новый параметр.
Если вы кодируете ваши собственные значения в URL, используйте функцию urllib.encode() от модуля urllib подобно этому:
value_dict = { ‘param_1’ : ‘value1’, ‘param_2’ : ‘value2’ }
encoded_params = urllib.encode(value_dict)
full_link = script_url + ‘?’ + encoded_params
Получение данных из форм
Формы HTML инкапсулированы в запросы так, что хорошо отображаются в тип данных «словарь» Python. Каждый элемент формы имеет имя и соответственное значение.
Например, если элемент — это радиокнопка, то посланное значение — это значение выбранной кнопки. Например, в предыдущей форме радиокнопка имеет имя param2 и ее значение есть или this, или that. Для переключателя, скажем param3 или param4, посланное значение есть off или on.
Теперь, когда вы знаете основы того, как формы кодируются и отправляются к CGI скриптам, настало время представить вам модуль cgi. Модуль cgi — это ваш механизм для получения данных из формы. Он делает процесс кодирования очень легким.
Чтение данных формы слегка осложняется двумя фактами. Для начала, имена входных элементов формы могут повторяться, так что значения могут быть списками. (Представьте себе форму, которая позволяет вам выбрать все правильные ответы.) Во-вторых, по умолчанию входной элемент, который не имеет никакого значения — как например текстовое поле, которое не заполнено — будет скорее отсутствовать, чем быть просто пустым.
Метод FieldStorage() модуля cgi возвращает объект, который представляет данные формы. Он — почти словарь. Вместо того, чтобы повторять страницу руководства об использовании модуля cgi, давайте помотрим на пару функций общего назначения, которые принимают объект, созданный FieldStorage() и возвращают словари.
Функции

def getform(theform, valuelist, notpresent='', nolist=False):
    """
    This function, given a CGI form as a
    FieldStorage instance, extracts the
    data from it, based on valuelist
    passed in. Any non-present values are
    set to '' - although this can be
    changed. (e.g. to return None so you
    can test for missing keywords - where
    '' is a valid answer but to have the
    field missing isn't.) It also takes a
    keyword argument 'nolist'. If this is
    True list values only return their
    first value.
    """
    data = {}
    for field in valuelist:
        if not theform.has_key(field):
        #  if the field is not present (or was empty)
            data[field] = notpresent
        else:
        # the field is present
            if  type(theform[field]) != type([]):
            # is it a list or a single item
                data[field] = theform[field].value
            else:
                if not nolist:
                # do we want a list ?
                    data[field] = theform.getlist(field)
                else:
                    data[field] = theform.getfirst(field)
                    # just fetch the first item
            return data

def getall(theform, nolist=False):
    """
    Passed a form (cgi.FieldStorage
    instance) return *all* the values.
    This doesn't take into account
    multipart form data (file uploads).
    It also takes a keyword argument
    'nolist'. If this is True list values
    only return their first value.
    """
    data = {}
    for field in theform.keys():
    # we can't just iterate over it, but must use the keys() method
        if type(theform[field]) ==  type([]):
            if not nolist:
                data[field] = theform.getlist(field)
            else:
                data[field] = theform.getfirst(field)
        else:
            data[field] = theform[field].value
    return data

def isblank(indict):
    """
    Passed an indict of values it checks
    if any of the values are set. Returns
    True if the indict is empty, else
    returns False. I use it on the a form
    processed with getform to tell if my
    CGI has been activated without any
    form values.
    """
    for key in indict.keys():
        if indict[key]:
            return False
    return True 

Почти для всех CGI скриптов, которые получают входные данные от формы, вы будете знать, какие параметры ожидать. (В конце концов, вероятно вы сами и написали форму.) Если вы передаете функции getform() экзампляр FieldStorage() и список всех параметров, которые вы ожидаете получить, она возвращает словарь значений. Любые отсутствующие параметры имеют значение по умолчанию », если только вы не изменяли ключевое слово notpresent. Если вы хотите убедиться, что вы не получаете никаких списковых значений, установите ключевое слово nolist. Если переменная формы была списком, nolist возвращает только первое значение в списке.
Или, если вы хотите получить все значения, посланные формой, используйте функцию getall(). Она также принимает ключевое слово nolist как необязательный аргумент.
isblank() — это специальная функция: она проводит быструю проверку, чтобы определить все ли значения содержатся в словаре, возвращенном getall(), или getform() пуст. Если это так, CGI скрипт был вызван без параметров. В таком случае обычно генерируется страница приветствия и форма. Если словарь не пуст (isblank() возвращает False), форма содержит данные для обработки.
Использование getform()
Давайте обработаем данные из примера формы, описанной выше. Этой части программы нужны предыдущие функции и первые несколько строк программы Hello World.
import cgi

mainpage = '''<html><head><title>Receiving a 
  Form</title></head><body>%s</body></html>'''
error = '''
<h1>Error</h1>
<h2>No Form Submission Was Received</h2>

'''
result = '''
<h1>Receiving a Form Submission</h1>

We received the following parameters from the form :
<ul>
<li>Your name is "%s".</li>
<li>You selected "%s".</li>
<li>"this" is "%s". </li>
<li>"this too" is "%s". </li>
<li> A hidden parameter was sent "%s".</li>
</ul>

'''
possible_parameters = ['param1', 'param2', 'param3', 'param4', 
  'hidden_param']

if __name__ == '__main__':
    cgiprint(contentheader)   # content header
    cgiprint()                # finish headers with blank line

    theform = cgi.FieldStorage()

    formdict = getform(theform, possible_parameters)
    if isblank(formdict):
        body = error
    else:
        name = formdict['param1']
        radio = formdict['param2']  # should be 'this' or 'that'
        check1 = formdict['param3'] # 'on' or 'off'
        check2 = formdict['param4']
        hidden = formdict['hidden_param']

        body = result % (name, radio, check1, check2, hidden)

    print mainpage % body

Давайте обсудим код. Есть три главных отрезка html: mainpage — это рамка страницы, которой только нужно тело для вставки внутрь нее. error показывается, если сценарий выл вызван без параметров. Однако, если сценарий вызван путем отправки формы, то параметры извлекаются и помещаются в result.
Сценарий печатает обязательные заголовки, а затем создает экземпляр FieldStorage, чтобы представить данные формы. Затем theform передается функции getform() наряду со списком ожидаемых параметров.
Если форма не была послана, то все значения в словаре, возвращенном getform() пусты (то есть »). В данном случае isblank() возвращает True и body установлена, чтобы быть сообщением об ошибке.
Если форма была послана, то isblank() возваращает False и значения из словаря извлекаются и вставляются в result. Переменная name содержит имя введенное в текстовое поле. Значение радиокнопки (в radio) или this, или that, в зависимости от того, какае значение было выбрано. check1 и check2 установлены в off или on в зависимости от того, были ли выбраны соответствующие переключатели. Скрытый параметр возвращается всегда.
Наконец страница напечатана, показывая или ошибку, или результаты. Легко или нет? Использование скрытых значений открывает возможность создания уникальных значений и кодирования их в форму. Это могло бы связать запросы вместе, так что вы можете динамически скроить содержимое для каждого пользователя, так как они проходят через ваше приложение (но это другая история).
Использование getall()
Если бы приложение было больше, возможно с несколькими формами, вы могли бы не знать заранее какие параметры будут введены. В таком случае вы можете использовать getall() вместо getform(). Тогда вы можете проверить существование определенных параметров и выполнить различные действия в зависимости от того, какая форма была отправлена:

formdict = getall(theform)
if formdict.has_key('rating'):
    process_feedback(formdict)
    # пользователь вводит обратную связь
elif formdict.has_key('email'):
    subscribe(formdict)
    # пользователь подписывается на рассылку
else:
    optionlist()
    # показать форму со всеми вариантами

Используя getall(), фактически вы можете переделать наш последний сценарий во что-нибудь немного более общее и полезное:
import cgi

mainpage = '''<html><head><title>Receiving a 
  Form</title></head><body>%s</body></html>'''
result = '''
<h1>Receiving a Form Submission</h1>

We received the following parameters from the form :
<ul>%s</ul>

'''
li = "
<li>%s = %s</li>

"

if __name__ == '__main__':
    cgiprint(contentheader)   # заголовок содержимого
    cgiprint()                # завершить заголовки пустой линией

    theform = cgi.FieldStorage()
    formdict = getall(theform)
    params = []
    for entry in formdict:
        params.append(li % (entry, str(formdict[entry])))

    print mainpage % (result % ''.join(params))

Этот код получает все введенные параметры используя getall(). Затем он вставляет их в страницу как неопределенный список. Если вы посылаете этому сценарию форму, он показывает вам все полученные параметры на странице, где каждая строка выглядит как «параметр = значение». Поскольку строка кода, которая производит это, использует str() функция для каждого значения, она может справиться со списками.
Список значений
Различные параметры формы могут иметь одинаковые имена. В данном случае, значение, возвращенное в FieldStorage — это список. Вы могли бы использовать это для сбора информации от вашего пользователя. Например, список тем для информационных бюллетеней, которых вы, возможно, рассылаете.

<form action="/cgi-bin/formprocessor.py" method="get">
  What is Your Name : <input name="name"
    type="text" value="Joe Bloggs" />
Email Address : <input name="email"
    type="text" />
<input name="interests" type="checkbox"  value="computers" />Computers
<input name="interests" type="checkbox"  value="sewing" />Sewing
<input name="interests" type="checkbox"  value="ballet" />Ballet
<input name="interests" type="checkbox"  value="scuba" />Scuba Diving
<input name="interests" type="checkbox"  value="cars" />Cars
<input type="reset"  />
  <input type="submit" />
</form>

Когда эта форма отсылается, она будет содержать именя пользователя, его адрес электронной почты и список всех интересов, которые он отметил. Код получения значений из экземпляра FieldStorage:
import cgi
theform = cgi.FieldStorage()
interests = theform[‘interests’].value
Трудность в том, что если пользователь отмечает только один интерес, тогда интересы — это единое значение вместо списка, который мы ожидаем. Альтернатива — использовать высокоуровневые методы, доступные в FieldStorage.
Метод Getlist() всегда возвращает список, даже если было введено только одно значение. Если выбор вообще не был сделан, он возвращает пустой список.
import cgi
theform = cgi.FieldStorage()
interests = theform.getlist(‘interests’)
Было бы очень легко приспособить функции getform() и getall() к вашим специфическим потребностям при работе со значениями, которые будут списками.

Экспериментируйте
Вам не нужен выделенный сервер, чтобы отлаживать CGI скрипты. Вы можете кодировать и отлаживать веб приложения на вашей настольной машине, и это является хорошей новостью для тех, кто все еще платит за поминутный доступ в Интернета. Использую локальный веб-сервер на вашей собственной машине, вы можете выполнять цикл «кодировать, тестировать, рвать волосы, отлаживать» дома. Попробуйте Xitami_. Это — быстрый и легкий веб-сервер, особенно для платформы Windows.
Нужно проявить внимание при настройке CGI на сервере. Это не трудно, но есть несколько шагов, которые должны быть сделаны.
Если сценарий перемещают на другой сервер, вам вероятно придется поместить его на сервер с помощью FTP. Ваш FTP-клиент должен быть настроен так, чтобы пересылать сценарии Python как текст. Скопируйте в нужный каталог, установите корректные права доступа. Проверьте путь к интрепретатору.
Веб-страница с примерами CGI http://www.voidspace.org.uk/python/cgi.shtml. Скрипты доступны для проверки или загрузке. Они включают генератор анаграмм и различные более маленькие тестовые сценарии. Есть также полный набор инструметов для создания аутентификации пользователей и управления с помощью CGI logintools.
Приичины ошибки 500
Отладка CGI скриптов может быть тяжелым процессом. По умолчанию какая-нибудь проблема с вашим сценарием CGI приводит к анонимной ошибке 500. Фактические детали ошибки вписаны в лог файл веб-сервера, который может быть полезен, если вы имеете доступ к этому файлу.
Однако, более чем половина 500 ошибок может быть легко устранена путем проверки следующих общих источников ошибок. Вы будете удивлены как часто вы будуете допускать некоторые из них.
Был ли ваш сценарий помещен на сервер в ‘текстовом’ режиме? (Настроен ли ваш FTP-клиентдля пересылки файлов .py в текстовом режиме?)
Установили ли вы скрипту корректные права доступа 755? (выполнение для всех)?
Установили ли вы правильный путь к интерпретатору в первой строке?
Напечатали ли вы корресктные заголовки, в том числе заключительную пустую строку?
Кроме того, некоторые серверы требуют, чтобы скрипт находился в каталоге cgi-bin (или его подкаталоге), и некоторые даже требуют, чтобы расширение файла было .cgi вместо .py.
Заключение
Мы обсудили все основы CGI. Информация здесь достаточна для начала работы, или хотя бы как минимум для поиска нужных материалов для самообучения.
Однако осталось еще много тем: кодировки символов, использование шаблонов для вывода подобного кода HTML, получение информации о HTTP-запросе пользователя и т.д.

python3 -m http.server --cgi

from http.server import HTTPServer, CGIHTTPRequestHandler
server_address = ("", 8000)
httpd = HTTPServer(server_address, CGIHTTPRequestHandler)
httpd.serve_forever()

#!/usr/bin/env python3

print("Content-type: text/html")
print()
print("<h1>Hello world!</h1>")

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