Requests post


Всем привет. Сегодня мы рассмотрим интересный модуль requests позволяющий отправлять различные http запросы. Итак, поехали!

Для начала устанавливаем модуль через pip.

pip install requests

Затем импортируем его в программу.

import requests

Все теперь мы можем с ним работать.

Отправим обычный get запрос на главную страницу моего блога.

response = requests.get('https://webfanat.com')    print(response)

Здесь мы с помощью метода get() отправили get запрос на страницу по адресу https://webfanat.com и в переменную response получили ответ.

Теперь сам ответ мы можем обрабатывать через специальные методы и свойства.

К примеру свойство status_code вернет нам код статуса ответа от сервера.

print(response.status_code)

Если вернется код со статусом 200, это значит что запрос успешно выполнен и страница найдена.

Для просмотра содержимого ответа мы можем воспользоваться свойством content.

print(response.content)  

Нам вернется все содержимое которое содержит ответ.

Можно также просматривать заголовки ответа.

print(response.headers)

Здесь c помощью свойства headers мы просматриваем все возвращенные заголовки ответа нашего запроса.

Если мы хотим просмотреть отдельный заголовок, к примеру Set-Cookie:

print(response.headers.get('Set-Cookie'))

К свойству headers добавляем метод get() в котором указываем название заголовка. И в результате нам возвращается его содержимое.

Для получения возвращаемого контента ответа, нужно обратится к свойству text.

print(response.text)

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

content = response.text    file = open('index.php', 'w')    file.write(content)    file.close()

В результате создастся файл index.php куда и будет помещен html код.

Еще если в качестве ответа от сервера возвращается строка в json формате мы можем ее обработать через метод json().

print(response.json())

В итоге у нас строка преобразуется в json объект.

Отлично! C обработкой запросов мы с вами разобрались. Теперь вернемся в начало к отправке запроса.

Метод get() объекта requests помимо адреса куда будет отправляться запрос может принимать еще такие параметры, как headers(заголовки) и params(параметры).

Пример:

param = {'id': 4}    header = {'Set-cookie': '5ceeuc6ee6e5ece'}    response = requests.get('https://webfanat.com/article_id', params=param, headers=header)    print(response.text)  

Здесь мы отправляем запрос по адресу https://webfanat.com/article_id?id=4 и передаем заголовок Set-cookie: 5ceeuc6ee6e5ece.

Как видите значения параметром params и headers устанавливается в формате json.

В итоге мы через свойство text выводим содержимое страницы https://webfanat.com/article_id?id=4.

Подобную схему мы можем использовать и при отправке post() запросов:

field = {'login': 'ajfjvfd', 'password': 'fdcfdccsd'}    header = {'Set-cookie': 'b47ctr46ctb6r43tbcf4'}    res = requests.post("http://webfanat.com/login", data=field, headers=header)    print(res.text)

Обратите внимание что здесь мы вместо параметра params используем параметр data. Это связано с тем что мы данные в post запросе передаем не через адресную строку.

Для передачи файлов через post запрос используется параметр files.

Вот в принципе и все что я хотел вам рассказать про работу с модулем requests. Мы рассмотрели самое основное. Put, delete, head и options запросы мы рассматривать не будем, так как они не так часто используются.

На этом данная статья подошла к концу. Если у вас остались вопросы, пишите в комментариях или группе

вк.

я с вами прощаюсь. Желаю вам успехов и удачи! Пока.

webfanat.com


Генерация HTTP запросов

Антон Калмыков (Antonio)

2001-03-26

Имитация броузера, «бомбежка» форм. GET и POST запросы, куки, закачка файлов.

В последнее время я все более часто наблюдаю в основном форуме РНРClub вопросы на тему создания POST и GET запросов, а так же вопросы на тему: «Как мне посредством функции header сформировать POST запрос». Я считаю, что уже давно назрела необходимость расставить точки над «и» в использовании данной технологии, поскольку начинающие программисты просто не понимают принципов работы веба, как такового. Итак, начнем наше путешествие по миру протокола HTTP.

1. Протокол HTTP. Введение

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

1.1 Клиент и сервер


Чудес в мире, а тем более в мире программизма и интернета не бывает! Усвойте это как незыблемую истину. И, если программа не работает или работает не так как хочется, то, значит, скорее всего, она либо написана не правильно, либо содержит ошибки. Итак, как же все-таки браузер просит сервер прислать ему хоть что-нибудь? Да очень просто! Надо только немного расслабиться и начать получать удовольствие от процесса 🙂

1.2. Пишем наш первый HTTP запрос

Если Вы думаете, что все слишком сложно, то Вы ошибаетесь. Человек так устроен, что просто не способен создавать что-то сложное, иначе он сам в этом запутается 🙂 Итак, есть браузер и есть Web-сервер. Инициатором обмена данными всегда выступает браузер. Web-сервер никому, никогда просто так ничего не пошлет, чтобы он что-нибудь отправил браузеру — надо, чтобы браузер об этом попросил. Простейший HTTP запрос моет выглядеть, например, так:

GET http://www.php.net/ HTTP/1.0\r\n\r\n

  • GET (В переводе с английского означает «получить») — тип запроса, тип запроса может быть разным, например POST, HEAD, PUT, DELETE (часть из них мы рассмотрим ниже).
  • http://www.php.net/ — URI (адрес) от которого мы хотим получить хоть какую-нибудь информацию (естественно мы надеемся подучить HTML страницу).
  • HTTP/1.0 — тип и версия протокола, который мы будем использовать в процессе общения с сервером.
  • \r\n — конец строки, который необходимо повторить два раза, зачем, станет понятно немного позднее.

Вы можете выполнить данный запрос очень просто. Запустите программу telnet.exe, введите в качестве хоста www.php.net, укажите порт 80, и просто наберите данный запрос, нажав два раза Enter в качестве \r\n\r\n. В ответ вы получите HTML код главной страницы сайта www.php.net.

1.3 Структура запроса

Рассмотрим, из чего состоит HTTP запрос. Все достаточно просто. Начнем с того, что HTTP запрос — это вполне осмысленный текст. Из чего же он состоит в общем случае? Будем рассматривать протокол HTTP 1.0. Итак:

Request-Line [ General-Header | Request-Header | Entity-Header ]\r\n[ Entity-Body ]
  • Request-Line — строка запроса
  • Формат: «Method Request-URI HTTP-Version\r\n»

  • Method — метод, которым будет обрабатываться ресурс Request-URI, может быть GET, POST, PUT, DELETE или HEAD.
  • Request-URI — относительная или абсолютная ссылка на страницу с набором параметров, например, /index.html или http://www.myhost.ru/index.html или /index.html?a=1&b=qq. В последнем случае серверу будет передан запрос с набором переменных a и b с соответствующими значениями, а знак «&» — амперсант служит разделителем между параметрами.
  • HTTP-Version — версия HTTP протокола, в нашем случае «HTTP/1.0».

Нам крайне интересны методы обработки GET и POST. Методом GET можно просто передать параметры в скрипт, а методом POST можно эмулировать submit формы.

Для метода GET, Request-URI может выглядеть, например, так: «/index.html?param1=1&param2=2».

  • General-Header — главная часть заголовка.
    Формат: [Date: value\n | Pragma: no-cache\n]
    Может иметь только два параметра: Date или Pragma. Date — дата по Гринвичу в формате «День недели, Число Месяц Год ЧЧ:ММ:СС GMT», например, «Tue, 15 Nov 1994 08:12:31 GMT» — дата создания запроса. Pragma может иметь одно значение no-cache, которое запрещает кэширование страницы.
  • Request-Header — часть заголовка, описывающая запрос.

    Request-Header может иметь следующие параметры: Allow, Authorization, From, If-Modified-Since, Referer, User-Agent.
    В данной главе мы не будем рассматривать параметр Autorization, так как он используется для доступа к закрытым ресурсам, что требуется не так уж часто. Вы можете самостоятельно изучить формирование заголовка для авторизованного доступа на сайте www.w3c.org.


  • Allow — задает допустимые методы обработки.
    Формат: «Allow: GET | HEAD\n».
    Параметр игнорируется при указании метода обработки POST в Request-Line. Задает допустимые методы обработки запроса. Прокси сервера не модифицируют параметр Allow и он в неизменном виде доходит до сервера.
  • From — e-mail адрес, пославшего запрос.
    Формат: «From: adderss\r\n».
    Например, «From: myname@mailserver.ru\r\n».
  • If-Modified-Since — указывает, что запрос не модифицировался с такого-то времени.
    Формат: «If-Modified-Since: date\r\n»
    Используется только для метода обработки GET. Дата указывается по Гринвичу в таком же формате, как и для параметра Date в General-Header.
  • Referrer — абсолютная ссылка на страницу, с которой произошла инициация запроса, т. е. ссылка на страницу, с которой пользователь перешел на нашу.
    Формат: «Referrer: url\n».
    Пример: «Referrer: www.host.ru/index.html\n».
  • User-Agent — тип браузера.
    Например: «User-Agent: Mozilla/4.0\n»
  • Entity-Header — часть заголовка, описывающая данные Entity-Body.
    В данной части запроса задаются параметры, которые описывают тело страницы. Entity-Header может содержать следующие параметры: Allow, Content-Encoding, Content-Length, Content-Type, Expires, Last-Modified, extension-header.

  • Allow — параметр аналогичный Allow из General-Header.
  • Content-Encoding — тип кодирования данных Entity-Body.
    Формат: «Сontent-Encoding: x-gzip | x-compress | другой тип\n».
    Пример: «Сontent-Encoding: x-gzip\n». Символ «|» означает слово «или», то есть то или то или то и.т.д.
    Другой тип может указывать на способ кодирования данных, например, для метода POST: «Сontent-Encoding: application/x-www-form-urlencoded\n».
  • Content-Length — количество байт, пересылаемых в Entity-Body. Значение Content-Length имеет совсем другой смысл для данных, пересылаемых в формате MIME, где он выступает как параметр описания части данных — «external/entity-body». Допустимыми являются целые числа от нуля и больше.
    Пример: «Content-Length: 26457\n».
  • Content-Type — тип передаваемых данных.
    Например: «Content-Type: text/html\n».
  • Expires — Время, когда страница должна быть удалена из кэша браузера.
    Формат: «Expires: date\n». Формат даты алогичен формату даты для параметра Date из General-Header.
  • Last-Modified — время последнего изменения пересылаемых данных.
    Формат: «Last-Modified: date\n». Формат даты алогичен формату даты для параметра Date из General-Header.

  • Extention-header — часть заголовка, которая может предназначаться, например, для обработки браузером, или другой программой, которая принимает документ. В данной части можно описывать свои параметры в формате «ParameterName: parametervalue\n». Данные параметры будут игнорироваться, если программа-клиент не знает, как их обработать.
    Например: «Cookie: r=1\r\n» — устанавливает всем известные печеньки для страницы.

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

Давайте представим, что нам надо получить страницу с сайта, передав Cookies (Печеньки), иначе нас просто пошлют как незванных гостей, и более того, известно, что на данную страницу пускают только после того, как Вы побывали на главной странице сайта.

2 Метод GET

Напишем наш запрос.

GET http://www.site.ru/news.html HTTP/1.0\r\n  Host: www.site.ru\r\n  Referer: http://www.site.ru/index.html\r\n  Cookie: income=1\r\n  \r\n

Данный запрос говорит нам о том, что мы хотим получить содержимое страницы по адресу http://www.site.ru/news.html, использую метод GET. Поле Host говорит о том, что данная страница находится на сервере www.site.ru, поле Referer говорит о том, что за новостями мы пришли с главной страницы сайта, а поле Cookie говорит о том, что нам была присвоена такая-то кука.


чему так важны поля Host, Referer и Сookie? Потому что нормальные программисты при создании динамических сайтов проверяют данные поля, которые появляются в скриптах (РНР в том числе) в виде переменных. Для чего это надо? Для того, например, чтобы сайт не грабили, т.е. не натравливали на него программу для автоматического скачивания, или для того, чтобы зашедший на сайт человек всегда попадал бы на него только с главной страницы и.т.д.

Теперь давайте представим, что нам надо заполнить поля формы на странице и отправить запрос из формы, пусть в данной форме будет два поля: login и password (логин и пароль),- и, мы естественно знаем логин и пароль.

  GET http://www.site.ru/news.html?login=Petya%20Vasechkin&password=qq HTTP/1.0\r\n  Host: www.site.ru\r\n  Referer: http://www.site.ru/index.html\r\n  Cookie: income=1\r\n  \r\n  

Логин у нас «Petya Vasechkin» Почему же мы должны писать Petya%20Vasechkin? Это из=за того, что специальные символы могут быть распознаны сервером, как признаки наличия нового параметра или конца запроса и.т.д. Поэтому существует алгоритм кодирования имен параметров и их значений, во избежание оштбочных ситуаций в запросе. Полное описание данного алгоритма можно найти здесь, а в PHP есть функции rawurlencode и rawurldecode для кодирования и декодирования соответственно. Хочу отметеить, что декодирование РНР делает сам, если в запросе были переданы закодированные параметры. На этом я закону первую главу знакомства c протоколом HTTP. В следуючей главе мы рассмотрим построение запросов типа POST (в переводе с английского — «отправить»), что будет гораздо интереснее, т.к. именно данный тип запросов используется при отправке данных из HTML форм.

3. Метод POST.

В случае HTTP запроса типа POST существует два варианта передачи полей из HTML форм, а именно, используя алгоритм application/x-www-form-urlencoded и multipart/form-data. Различия между данными алгоритмами весьма существенные. Дело в том, что алгоритм первого типа создавался давным-давно, когда в языке HTML еще не предусматривали возможность передачи файлов через HTML формы. Итак, давайте рассмотрим эти алгоритмы на примерах.

3.1 Content-Type: application/x-www-form-urlencoded.

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

  POST http://www.site.ru/news.html HTTP/1.0\r\n   Host: www.site.ru\r\n   Referer: http://www.site.ru/index.html\r\n   Cookie: income=1\r\n   Content-Type: application/x-www-form-urlencoded\r\n  Content-Length: 35\r\n  \r\n  login=Petya%20Vasechkin&password=qq  

Здесь мы видим пример использования Content-Type и Content-Length полей заголовка. Content-Length говорит, сколько байт будет занимать область данных, которая отделяется от заголовка еще одним переводом строки \r\n. А вот параметры, которые раньше для запроса GET помещались в Request-URI, теперь находятся в Entity-Body. Видно, что они формируются точно также, просто надо написать их после заголовка. Хочу отметить еще один важный момент, ничто не мешает, одновременно с набором параметров в Entity-Body, помещать параметры с другими именами в Request-URI, например:

  POST http://www.site.ru/news.html?type=user HTTP/1.0\r\n   .....  \r\n  login=Petya%20Vasechkin&password=qq  

3.2 Content-Type: multipart/form-data

Как только интернет мир понял, что неплохо бы было через формы отсылать еще и файлы, так W3C консорциум взялся за доработку формата POST запроса. К тому времени уже достаточно широко применялся формат MIME (Multipurpose Internet Mail Extensions — многоцелевые расширения протокола для формирования Mail сообщений), поэтому, чтобы не изобретать велосипед заново, решили использовать часть данного формата формирования сообщений для создания POST запросов в протоколе HTTP.

Каковы же основные отличия этого формата от типа application/x-www-form-urlencoded?

Главное отличие в том, что Entity-Body теперь можно поделить на разделы, которые разделяются границами (boundary). Что самое интересное — каждый раздел может иметь свой собственный заголовок для описания данных, которые в нем хранятся, т.е. в одном запросе можно передавать данные различных типов (как в Mail письме Вы одновременно с текстом можете передавать файлы).

Итак, приступим. Рассмотрим опять все тот же пример с передачей логина и пароля, но теперь в новом формате.

  POST http://www.site.ru/news.html HTTP/1.0\r\n   Host: www.site.ru\r\n   Referer: http://www.site.ru/index.html\r\n   Cookie: income=1\r\n   Content-Type: multipart/form-data; boundary=1BEF0A57BE110FD467A\r\n  Content-Length: 209\r\n  \r\n  --1BEF0A57BE110FD467A\r\n  Content-Disposition: form-data; name="login"\r\n  \r\n  Petya Vasechkin\r\n  --1BEF0A57BE110FD467A\r\n  Content-Disposition: form-data; name="password"\r\n  \r\n  qq\r\n  --1BEF0A57BE110FD467A--\r\n

Теперь давайте разбираться в том что написано. 🙂 Я специально выделил некоторые символы \r\n жирным, чтобы они не сливались с данными. Присмотревшись внимательно можно заметить поле boundary после Content-Type. Это поле задает разделитель разделов — границу. В качестве границы может быть использована строка, состоящая из латинских букв и цифр, а так же из еще некоторых символов (к сожалению, не помню каких еще). В теле запроса в начало границы добавляется '—', а заканчивается запрос — границей, к которой символы '—' добавляются еще и в конец. В нашем запросе два раздела, первый описывает поле login, а второй поле password. Content-Disposition (тип данных в разделе) говорит, что это будут данные из формы, а в поле name задается имя поля. На этом заголовок раздела заканчивается и далее следует область данных раздела, в котором помещается значение поля (кодировать значение не требуется!).

Хочу обратить Ваше внимание та то, что в заголовках разделов не надо использовать Content-Length, а вот в заголовке запроса надо и его значение является размером всего Entity-Body, стоящего после второго \r\n, следующего за Content-Length: 209\r\n. Т.е. Entity-Body отделяется от заголовка дополнительным переводом строки (что можно заметить и в разделах).

А теперь давайте напишем запрос для передачи файла.

  POST http://www.site.ru/postnews.html HTTP/1.0\r\n   Host: www.site.ru\r\n   Referer: http://www.site.ru/news.html\r\n   Cookie: income=1\r\n   Content-Type: multipart/form-data; boundary=1BEF0A57BE110FD467A\r\n  Content-Length: 491\r\n  \r\n  --1BEF0A57BE110FD467A\r\n  Content-Disposition: form-data; name="news_header"\r\n  \r\n  Пример новости\r\n  --1BEF0A57BE110FD467A\r\n  Content-Disposition: form-data; name="news_file"; filename="news.txt"\r\n  Content-Type: application/octet-stream\r\n  Content-Transfer-Encoding: binary\r\n  \r\n  А вот такая новость, которая лежит в файле news.txt\r\n  --1BEF0A57BE110FD467A--\r\n  

В данном примере в первом разделе пересылается заголовок новости, а во втором разделе пересылается файл news.txt. Внимательный да увидит поля filename и Content-Type во втором разделе. Поле filename задает имя пересылаемого файла, а поле Content-Type — тип данного файла. Application/octet-stream говорит о том, что это стандартный поток данных, а Content-Transfer-Encoding: binary говорит на о том, что это бинарные данные, ничем не закодированные.

Очень важный момент. Большинство CGI скриптов написано умными людьми, поэтому они любят проверять тип пришедшего файла, который стоит в Content-Type. Зачем? Чаще всего закачка файлов на сайтах используется для получения картинок от посетителя. Так вот, браузер сам пытается определить что за файл посетитель хочет отправить и вставляет соответствующий Content-Type в запрос. Скрипт его проверяет при получении, и, например, если это не gif или не jpeg игнорирует данный файл. Поэтому при «ручном» формировании запроса позаботьтесь о значении Content-Type, чтобы оно было наиболее близким к формату передаваемого файла.

image/gif для gif
image/jpeg для jpeg
image/png для png
image/tiff для tiff (что используется крайне редко, уж больно емкий формат)

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

4. Постскриптум.

Думаю, что о передаче запросов на сервер не стоит рассказывать подробно. Это уже дело чисто РНР техники :-). Достаточно внимательно прочитать раздел о функциях работы с сокетами, или о функциях модуля CURL в официальной документации РНР.

Из выше сказанного, надеюсь теперь понятно, почему вопрос: «Как мне сформировать POST запрос, используя функцию header?» — бессмысленен. Функция header(string) добавляет запись только в заголовок запроса, но никак не в тело запроса.

Есть еще один тип запросов — Content-Type: multipart/mixed, надеюсь после прочтения данной статьи Вы легко разберетесь с данным типом сами. Подробно изучить его можно Здесь

О запросах других типов можно прочитать в официальной спецификации протокола HTTP 1.0 здесь.

phpclub.ru

Создание запроса

Создание запроса с помощью Requests — это очень просто.

Начните с импорта модуля Requests:

>>> import requests 

Теперь попробуем получить веб-страницу. Например, давайте получим публичный тайм-лайн GitHub.

>>> r = requests.get('https://api.github.com/events') 

Теперь у нас есть объект Response с именем r. Мы можем получить всю необходимую информацию из этого объекта.

Простой API Requests означает, что все формы HTTP запросов являются очевидными. Например, вот как вы можете сделать HTTP POST запрос:

>>> r = requests.post("http://httpbin.org/post") 

Круто? А как насчет других типов HTTP запроса: PUT, DELETE, HEAD и OPTIONS? Их выполнить так же просто:

>>> r = requests.put("http://httpbin.org/put") >>> r = requests.delete("http://httpbin.org/delete") >>> r = requests.head("http://httpbin.org/get") >>> r = requests.options("http://httpbin.org/get")  

Это уже хорошо. Даже здорово. Но это далеко не все из того, что может делать Requests.

Передача параметров в URL

Часто вы хотите послать какие-то данные в строке запроса URL. Если вы строите URL вручную, то эти данные будут представлены в нем в виде пар ключ-значение после знака вопроса. Например, httpbin.org/get?key=val. Requests позволяет передать эти аргументы в качестве словаря, используя аргумент params. В качестве примера, если вы хотите передать key1=value1 и key2=value2 ресурсу httpbin.org/get, вы должны использовать следующий код:

>>> payload = {'key1': 'value1', 'key2': 'value2'} >>> r = requests.get("http://httpbin.org/get", params=payload) 

Вы можете видеть, что URL был закодирован правильно:

>>> print(r.url) http://httpbin.org/get?key2=value2&key1=value1 

Заметим, что любой ключ словаря, значение которого None, не будет добавлен к строке запроса URL.

Содержимое ответа

Мы можем читать содержимое ответа сервера. Рассмотрим тайм-лайн GitHub снова:

>>> import requests >>> r = requests.get('https://api.github.com/events')  >>> r.text  u'[{"repository":{"open_issues":0,"url":"https://github.com/...  

Requests будет автоматически декодировать содержимое ответа сервера. Большинство Unicode кодировок без проблем декодируются.

Когда вы делаете запрос, Requests делает предположение о кодировке, основанное на заголовках HTTP. Кодировка текста, угаданная Requests, используется при обращение к r.text. Вы можете узнать, какую кодировку использует Requests, и изменить её воспользовавшись свойством r.encoding:

>>> r.encoding 'utf-8'  >>> r.encoding = 'ISO-8859-1'  

Если вы измените кодировку, Requests будет использовать новое значение r.encoding всякий раз, когда вы будете использовать r.text. Вы можете сделать это в любой ситуации, где нужна более специализированная логика работы с кодировкой содержимого ответа. Например, в HTML и XML есть возможность задавать кодировку прямо в теле документа. В подобных ситуациях вы должны использовать r.content, чтобы найти кодировку, а затем установить r.encoding. Это позволит вам использовать r.text с правильной кодировкой.

Requests может также использовать пользовательские кодировки в случае, если вы в них нуждаетесь. Если вы создали свою собственную кодировку и зарегистрировали её в модуле codecs, вы можете просто использовать название кодека в качестве значения r.encoding, и Requests будет работать с этой кодировкой для вас.

Бинарное содержимое ответа

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

>>> r.content  b'[{"repository":{"open_issues":0,"url":"https://github.com/...  

Передача со сжатием gzip и deflate автоматически декодируется.

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

>>> from PIL import Image  >>> from StringIO import StringIO  >>> i = Image.open(StringIO(r.content))  

JSON содержимое ответа

С библиотекой Requests также поставляется встроенный JSON декодер на случай, если вы имеете дело с данными в формате JSON:

>>> import requests  >>> r = requests.get('https://api.github.com/events')  >>> r.json()  [{u'repository': {u'open_issues': 0, u'url': 'https://github.com/...  

В случае, если декодирование JSON не удается, r.json выбрасывает исключение. Например, если приходит ответ с кодом статуса 401 (неавторизованный), попытка обращения к r.json выбрасывает исключение ValueError: No JSON object could be decoded.

Необработанное содержимое ответа

В редких случаях, когда вы хотите получить доступ к сырому ответу сервера на уровне сокета, вы можете обратиться к r.raw. Если вы хотите сделать это, убедитесь, что вы установили stream=True в вашем первом запросе. После этого вы уже можете проделать следующее:

>>> r = requests.get('https://api.github.com/events', stream=True)  >>> r.raw  <requests.packages.urllib3.response.HTTPResponse object at 0x101194810>  >>> r.raw.read(10)  'x1fx8bx08x00x00x00x00x00x00x03'  

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

>>> with open(filename, 'wb') as fd:  >>> for chunk in r.iter_content(chunk_size):  >>> fd.write(chunk)  

Использование Response.iter_content будет обрабатывать многое из того, с чем бы вам пришлось иметь дело при использовании Response.raw напрямую. Описанное выше является предпочтительным и рекомендуемым способом извлечения содержимого при потоковой загрузке.

Пользовательские HTTP заголовки

Если вы хотите добавить HTTP-заголовки в запрос, просто передайте соответствующий словарь в параметре headers.

Например, мы не указали заголовок content-type в предыдущем примере:

>>> import json >>> url = 'https://api.github.com/some/endpoint' >>> payload = {'some': 'data'}  >>> headers = {'content-type': 'application/json'} >>> r = requests.post(url, data=json.dumps(payload), headers=headers) 

Более сложные POST запросы

Зачастую вы хотите послать некоторые form-encoded данные также как это делается в HTML форме. Чтобы сделать это, просто передайте соответствующий словарь в аргументе data. Ваш словарь данных в таком случае будет автоматически закодирован как HTML форма, когда будет сделан запрос:

>>> payload = {'key1': 'value1', 'key2': 'value2'}  >>> r = requests.post("http://httpbin.org/post", data=payload)  >>> print(r.text)  { ... "form": { "key2": "value2", "key1": "value1" }, ... }  

Но есть много случаев, когда вы можете захотеть отправить данные, которые не закодированы методом form-encoded. Если вы передадите в запрос строку вместо словаря, то данные будут отправлены в неизменном виде.

Например, API v3 GitHub принимает JSON-закодированные POST/PATCH данные:

>>> import json url = 'https://api.github.com/some/endpoint'  >>> payload = {'some': 'data'} >>> r = requests.post(url, data=json.dumps(payload))  

Как послать Multipart-Encoded файл

Requests позволяет легко послать на сервер Multipart-Encoded файлы:

>>> url = 'http://httpbin.org/post'  >>> files = {'file': open('report.xls', 'rb')} >>> r = requests.post(url, files=files)  >>> r.text  { ... "files": { "file": "<censored...binary...data>" }, ... }  

Вы можете установить имя файла, content-type и заголовки в явном виде:

>>> url = 'http://httpbin.org/post'  >>> files = {'file': ('report.xls', open('report.xls', 'rb'), 'application/vnd.ms-excel', {'Expires': '0'})}  >>> r = requests.post(url, files=files)  >>> r.text  { ... "files": { "file": "<censored...binary...data>" }, ... }  

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

>>> url = 'http://httpbin.org/post'  >>> files = {'file': ('report.csv', 'some,data,to,sendnanother,row,to,sendn')} >>> r = requests.post(url, files=files)  >>> r.text  { ... "files": { "file": "some,data,to,sendnanother,row,to,sendn" }, ... }  

В случае, если вы отправляете очень большой файл как multipart/form-data, вы можете захотеть отправить запрос потоком. По умолчанию requests не поддерживает этого, но есть отдельный пакет, который это делает — requests-toolbelt. Ознакомьтесь с документацию Toolbelt.

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

Коды состояния ответа

Мы можем проверить код состояния ответа:

>>> r = requests.get('http://httpbin.org/get')  >>> r.status_code  200  

Для удобства Requests также поставляется со встроенным объектом подстановок кодов состояния:

>>> r.status_code == requests.codes.ok  True  

Если мы сделали плохой запрос (ошибка 4XX клиента или ошибка 5XX ответа сервера), то мы можем возбудить исключение с помощью Response.raise_for_status() :

>>> bad_r = requests.get('http://httpbin.org/status/404')  >>> bad_r.status_code  404 >>> bad_r.raise_for_status()  Traceback (most recent call last):  File "requests/models.py", line 832, in raise_for_status  raise http_error requests.exceptions.HTTPError: 404 Client Error Traceback (most recent call last):  File "requests/models.py", line 832, in raise_for_status  raise http_error requests.exceptions.HTTPError: 404 Client Error  

Но если status_code для г оказался 200, то когда мы вызываем raise_for_status() мы получаем:

>>> r.raise_for_status()  None  

Это значит, что все в порядке.

Заголовки ответов

Мы можем просматривать заголовки ответа сервера, используя словарь Python:

>>> r.headers { 'content-encoding': 'gzip', 'transfer-encoding': 'chunked', 'connection': 'close', 'server': 'nginx/1.0.4', 'x-runtime': '148ms', 'etag': '"e1ca502697e5c9317743dc078f67693f"', 'content-type': 'application/json' }  

Однако это словарь особого рода: он сделан специально для HTTP заголовков. Согласно RFC 7230, имена заголовков HTTP нечувствительны к регистру.

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

>>> r.headers['Content-Type']  'application/json'  >>> r.headers.get('content-type')  'application/json'  

Cookies

Если ответ содержит cookie, вы можете быстро получить к ним доступ:

>>> url = 'http://example.com/some/cookie/setting/url'  >>> r = requests.get(url) >>> r.cookies['example_cookie_name']  'example_cookie_value'  

Для отправки собственных cookie на сервер, вы можете использовать параметр cookies:

>>> url = 'http://httpbin.org/cookies'  >>> cookies = dict(cookies_are='working') >>> r = requests.get(url, cookies=cookies)  >>> r.text  '{"cookies": {"cookies_are": "working"}}'  

Редиректы и история

По умолчанию Requests будет выполнять редиректы для всех HTTP глаголов, кроме HEAD.

Мы можем использовать свойство history объекта Response, чтобы отслеживать редиректы.

Список Response.history содержит объекты Response, которые были созданы во время выполнения запроса. Список сортируется от более ранних к более поздним ответам.

Например, GitHub перенаправляет все HTTP запросы на HTTPS:

>>> r = requests.get('http://github.com')  >>> r.url 'https://github.com/'  >>> r.status_code  200  >>> r.history  [<Response [301]>]  

Если вы используете GET, OPTIONS, POST, PUT, PATCH или DELETE, вы можете отключить обработку редиректов с помощью параметра allow_redirects:

>>> r = requests.get('http://github.com', allow_redirects=False)  >>> r.status_code  301  >>> r.history  []  

Если вы используете HEAD, вы можете включить обработку редиректов:

>>> r = requests.head('http://github.com', allow_redirects=True)  >>> r.url 'https://github.com/'  >>> r.history  [<Response [301]>] 

Тайм-ауты

Вы можете сказать Requests прекратить ожидание ответа после определенного количества секунд с помощью параметра timeout:

>>> requests.get('http://github.com', timeout=0.001)  Traceback (most recent call last):  File "<stdin>", line 1, in <module> requests.exceptions.Timeout: HTTPConnectionPool(host='github.com', port=80): Request timed out. (timeout=0.001) Traceback (most recent call last):  File "<stdin>", line 1, in <module> requests.exceptions.Timeout: HTTPConnectionPool(host='github.com', port=80): Request timed out. (timeout=0.001) 

Примечание: timeout это не ограничение по времени полной загрузки ответа. Исключение возникает, если сервер не дал ответ за timeout секунд (точнее, если ни одного байта не было получено от основного сокета за timeout секунд).

Ошибки и исключения

В случае неполадок в сети (например, отказа DNS, отказался соединения и т.д.), Requests возбудит исключение ConnectionError.

В более редком случае неверного HTTP ответа, Requests возбудит исключение HTTPError.

Если превышено время ожидания ответа, возбуждается исключение Timeout.

Если запрос превышает заданное значение максимального количества редиректов, то возбуждается исключение TooManyRedirects.

Все исключения, которые возбуждает непосредственно Requests, унаследованы от requests.exceptions.RequestException.

Готовы для большего?

Ознакомьтесь с дополнительным разделом документации.

Эта статья — перевод официальной документации Requests. Оригинал: Quickstart — Requests documentation.

m05quit0.ru

Post и Get запросы, какая между ними разница и что лучше и для каких целей?

тело сообщения (Entity Body) – необязательный параметр

Строка запроса – указывает метод передачи, URL-адрес, к которому нужно обратиться и версию протокола HTTP.

Заголовки – описывают тело сообщений, передают различные параметры и др. сведения и информацию.

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

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

Более подробно, каждый элемент запроса, мы рассмотрим в следующих заметках.

Давайте, для примера, рассмотрим один реальный запрос к серверу. Я выделил каждую часть запроса своим цветом: строка запроса — зеленый, заголовки — оранжевый, тело сообщения- голубой.

 

Запрос от браузера:

GET / HTTP/1.1

Host: webgyry.info

User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:18.0) Gecko/20100101 Firefox/18.0

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8

Accept-Language: ru-RU,ru;q=0.8,en-US;q=0.5,en;q=0.3

Accept-Encoding: gzip, deflate

Cookie: wp-settings

Connection: keep-alive

 

В следующем примере уже присутствует тело сообщения.

 

Ответ сервера:

HTTP/1.1 200 OK

Date: Sun, 10 Feb 2013 03:51:41 GMT

Content-Type: text/html; charset=UTF-8

Transfer-Encoding: chunked

Connection: keep-alive

Keep-Alive: timeout=5

Server: Apache

X-Pingback: //webgyry.info/xmlrpc.php

 

<!DOCTYPE html PUBLIC «-//W3C//DTD XHTML 1.0 Transitional//EN» «http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd»>

<html xmlns=»http://www.w3.org/1999/xhtml»>

<head>

<meta http-equiv=»Content-Type» content=»text/html; charset=utf-8″ />

<title>Документ без названия</title>

</head>

<body>

</body>

</html>

Вот такими сообщениями обмениваются клиент и сервер по протоколу HTTP.

Кстати, хотите узнать есть ли смысл в каком-то элементе на вашем сайте с помощью «целей» Яндекс Метрики и Google Analytics?

Requests post

Уберите то, что НЕ работает, добавьте то, что работает и удвойте вашу выручку.

Курс по настройке целей Яндекс Метрики..

Курс по настройке целей Google Analytics..

steptosleep.ru

Что такое HTML?

HTML — это язык, используемый для создания веб-страниц. Гипертекст относится к гиперссылкам, которые может содержать HTML-страница. Язык разметки означает способ использования тегов для определения макета страницы и элементов на странице.
Ниже приведен пример HTML, который используется для определения базовой веб-страницы с заголовком и одним абзацем текста:

<! doctype html>
<HTML>
<Голова>
<Название> TechTerms.com </ название>
</ HEAD>
<Тело>
<p> Это пример абзаца в HTML. </ p>
</ Body>
</ Html>

Первая строка определяет тип содержимого, содержащегося в документе. <! doctype html> означает, что страница написана в HTML5. Правильно отформатированные HTML-страницы должны включать теги <html>, <head> и <body>, которые все включены в пример выше. Заголовок страницы, метаданные и ссылки на файлы с привязкой помещаются между тегами <head>. Фактическое содержимое страницы находится между тегами <body>.

За последние несколько десятилетий сеть пережила множество изменений, но HTML всегда был основным языком, используемым для разработки веб-страниц. Интересно, что хотя веб-сайты стали более продвинутыми и интерактивными, HTML стал проще. Если вы сравниваете источник страницы HTML5 с аналогичной страницей, написанной в HTML 4.01 или XHTML 1.0, на странице HTML5 будет меньше кода. Это связано с тем, что современный HTML опирается на каскадные таблицы стилей или JavaScript для форматирования почти всех элементов внутри страницы.

Многие динамические веб-сайты генерируют веб-страницы «на лету», используя серверный язык сценариев, такой как PHP или ASP. Однако даже динамические страницы должны быть отформатированы с использованием HTML. Поэтому языки сценариев часто генерируют HTML-код, который отправляется в веб-браузер.post get запросы

Что такое HTTP?

Протокол передачи гипертекста HTTP предназначен для взаимодействия между клиентами и серверами и работает как протокол запроса-ответа.

Веб-браузер может быть клиентом, а приложение на компьютере, на котором размещен веб-сайт, — сервером.

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

Два метода запросов GET и POST

Два часто используемых метода для запроса-ответа между клиентом и сервером:

  • GET — запрашивает данные из указанного ресурса;

  • POST — отправляет данных, подлежащие обработке, на указанный ресурс.

Перевод GET и POST в буквальном смысле означает получение и постобработку.

Подробнее об HTTP

HTTP — это протокол, используемый для передачи данных через Интернет. Является частью пакета интернет-протокола и определяет команды и службы, используемые для передачи данных веб-страницы.

HTTP использует модель server-client. Клиент может быть домашним компьютером, ноутбуком или мобильным устройством. HTTP-сервер, как правило, является веб-хостом с программным обеспечением веб-сервера, таким как Apache или IIS. Когда пользователь получает доступ к веб-сайту, браузер отправляет запрос на соответствующий веб-сервер и отвечает кодом состояния HTTP. Если URL-адрес действителен и соединение предоставлено, сервер отправит браузеру веб-страницу и связанные файлы.get post php

Общие коды состояния HTTP включают:

  • 200 — успешный запрос (существует веб-страница);

  • 301 — перемещается постоянно (часто перенаправляется на новый URL-адрес);

  • 401 — несанкционированный запрос (требуется авторизация);

  • 403 — запрещено (доступ к странице или каталогу не разрешен);

  • 500 — внутренняя ошибка сервера (часто вызванная неправильной конфигурацией сервера).

POST и GET в HTTP

HTTP определяет команды GET и POST, которые используются для обработки представлений форм на веб-сайтах. Команда CONNECT используется для облегчения безопасного соединения, которое шифруется с использованием SSL. Зашифрованные HTTP-соединения происходят через HTTPS — расширение HTTP, предназначенное для защищенных передач данных.

URL-адреса, начинающиеся с «http://», доступны по стандартным протоколам передачи гипертекста и по умолчанию используют порт 80. URL-адреса, начинающиеся с «https://», доступны через безопасное соединение HTTPS и часто используют порт 443.wordpress get posts

POST

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

Операционные системы устройств Mac и Windows запускают POST каждый раз, когда компьютер загружается или перезапускается. Сканирование проверяет аппаратное обеспечение и гарантирует, что процессор, ОЗУ и устройства хранения данных будут работать правильно. Если во время выполнения POST возникла ошибка, процесс запуска может приостановиться или полностью прекратиться, а на мониторе может появиться сообщение о нештатной ситуации. На ПК ошибки POST часто отображаются на экране информации о BIOS. Они могут выводиться как криптовые коды, такие как «08», или как системное сообщение, например, «Ошибка системной памяти при смещении». На Mac ошибки POST часто обозначаются простой графикой, например, сломанной иконкой папки, которая указывает, что загрузочное устройство не найдено.

Физические проявления

В некоторых случаях экран компьютера может даже не включаться перед ошибками POST. Если это произойдет, коды ошибок могут выводиться через мигающие светодиодные индикаторы или звуковые сигналы. Например, Apple iMac будет воспроизводить три последовательных тона, выдерживать паузу в пять секунд, а затем повторять тоны, когда во время запуска обнаруживается плохая ОЗУ. Большинство ПК также издают звуковые сигналы при обнаружении ошибок POST, хотя каждый производитель использует свои собственные коды.http get post

POST — довольно технический термин, который используют только компьютерные техники на регулярной основе. Однако это хорошая аббревиатура, поскольку помогает лучше понять сообщения об ошибках, которые могут появиться на компьютерах или других электронных устройствах. Если компьютер не запускается из-за ошибки POST, можно использовать другое устройство для поиска значения и причины ошибки с веб-сайта производителя. Затем можно предпринять соответствующие действия — удаление модуля памяти или повторную установку видеокарты с последующим перезапуском оборудования.

GET

POST также является методом передачи переменных формы HTML с одной веб-страницы на другую, не отображая их в адресной строке. Альтернативный метод — GET, который добавляет значения в URL. Запросы HTTP POST предоставляют дополнительные данные от клиента (браузера) на сервер в теле сообщения. Напротив, запросы GET включают все необходимые данные в URL. Формы в HTML могут использовать любой метод, указав метод = POST или method = GET (по умолчанию) в элементе <form>. Указанный метод определяет, как данные формы передаются на сервер. Когда используется метод GET, все данные формы кодируются в URL-адрес в качестве параметров строки запроса. С POST данные формы появляются в теле сообщения HTTP-запроса.

Различия в представлении формы

Метод запроса POST запрашивает веб-сервер на прием и хранение данных, заключенные в тело сообщения запроса. Часто используется при загрузке файла или при отправке заполненной веб-формы.

Метод запроса HTTP GET извлекает информацию с сервера. В рамках запроса GET некоторые данные могут передаваться в строке запроса URL-адреса, указывая условия поиска, диапазоны дат или другую информацию, которая определяет запрос.

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

Основное различие между запросами GET и POST заключается в том, что они соответствуют различным HTTP-запросам, как определено в спецификациях HTTP. Процесс подачи обоих методов начинается таким же образом: набор данных формы создается браузером и затем кодируется способом, указанным атрибутом enctype. Для METHOD = «POST атрибут enctype может быть multipart/form-data или application/x-www-form-urlencoded, тогда как для METHOD =» GET » запускается только через application/x-www-form-urlencoded. Эти данные формы set затем передается на сервер.

Для отправки формы с помощью METHOD = «GET» браузер создает URL-адрес, принимая значение атрибута действия и добавляя к нему набор данных формы, закодированного с использованием типа контента application/x-www-form-urlencoded). Затем браузер обрабатывает этот URL-адрес, как если бы он ссылался на ссылку (или, как если бы пользователь набрал URL-адрес вручную). Браузер делит URL на части и распознает хост, затем отправляет на этот хост запрос GET с остальной частью URL в качестве аргумента. Важно отметить, что этот процесс означает, что данные формы ограничены кодами ASCII. Особое внимание следует уделять кодированию и декодированию других типов символов при передаче их по URL-адресу в формате ASCII.

Представление формы с METHOD = «POST» вызывает отправку запроса POST с использованием значения атрибута действия и сообщения, созданного в соответствии с типом контента, указанным атрибутом enctype.get post перевод

PHP

PHP — это язык веб-скриптов, встроенный в HTML. Это означает, что PHP-код можно вставить в HTML-страницу. Код PHP читается или анализируется сервером, на котором находится страница. Вывод функций GET и POST в PHP на странице обычно возвращается как HTML-код, который может быть прочитан браузером. Поскольку PHP-код преобразуется в HTML до загрузки страницы, пользователи не могут просматривать PHP-код на странице. Это делает страницы PHP достаточными для доступа к базам данных и другой защищенной информации.

Большая часть синтаксиса PHP заимствована из других языков, таких как C, Java и Perl. Однако PHP имеет ряд уникальных функций и специальных функций. Цель этого языка — дать возможность веб-разработчикам быстро и легко писать динамически сгенерированные страницы.

WordPress

WordPress — это бесплатная система управления контентом, используемая для создания и обслуживания веб-сайтов. Его простота использования и уникальные функции ведения блога помогли ему стать самым популярным инструментом ведения блогов в Интернете.

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

Несмотря на то что доступны тысячи шаблонов WordPress и плагинов, система POST GET в WordPress все еще имеет свои ограничения. Поскольку это служба на основе шаблонов, пользователь должен начать с заранее созданного веб-сайта, а не создавать страницы с нуля. Кроме того, нет возможности вставлять скрипты или поддерживать базу данных с тем же уровнем контроля, который предлагает пользовательский веб-сайт.get post id

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

fb.ru

This post discusses two HTTP (Hypertext Transfer Protocol) request methods  GET and POST requests in Python and their implementation in python.

What is HTTP?
HTTP is a set of protocols designed to enable communication between clients and servers. It works as a request-response protocol between a client and server.
A web browser may be the client, and an application on a computer that hosts a web site may be the server.

So, to request a response from the server, there are mainly two methods:

  1. GET : to request data from the server.
  2. POST : to submit data to be processed to the server.

Here is a simple diagram which explains the basic concept of GET and POST methods.iservice_post_get
Now, to make HTTP requests in python, we can use several HTTP libraries like:

  • httplib
  • urllib
  • requests

The most elegant and simplest of above listed libraries is Requests. We will be using requests library in this article. To download and install Requests library, use following command:

pip install requests

OR, download it from here and install manually.

Making a Get request

Output:
1

The above example finds latitude, longitude and formatted address of a given location by sending a GET request to the Google Maps API. An API (Application Programming Interface) enables you to access the internal features of a program in a limited fashion. And in most cases, the data provided is in JSON(JavaScript Object Notation) format (which is implemented as dictionary objects in Python!).

Important points to infer :

  • PARAMS = {'address':location}

    The URL for a GET request generally carries some parameters with it. For requests library, parameters can be defined as a dictionary. These parameters are later parsed down and added to the base url or the api-endpoint.
    To understand the parameters role, try to print r.url after the response object is created. You will see something like this:

    http://maps.googleapis.com/maps/api/geocode/json?address=delhi+technological+university

    This is the actual URL on which GET request is made

  • r = requests.get(url = URL, params = PARAMS)

    Here we create a response object ‘r’ which will store the request-response. We use requests.get() method since we are sending a GET request. The two arguments we pass are url and the parameters dictionary.

  • data = r.json()

    Now, in order to retrieve the data from the response object, we need to convert the raw response content into a JSON type data structure. This is achieved by using json() method. Finally, we extract the required information by parsing down the JSON type object.

Making a POST request

This example explains how to paste your source_code to pastebin.com by sending POST request to the PASTEBIN API.
First of all, you will need to generate an API key by signing up here and then access your API key here.

Important features of this code:

  • data = {'api_dev_key':API_KEY,   'api_option':'paste',   'api_paste_code':source_code,   'api_paste_format':'python'}

    Here again, we will need to pass some data to API server. We store this data as a dictionary.

  • r = requests.post(url = API_ENDPOINT, data = data)

    Here we create a response object ‘r’ which will store the request-response. We use requests.post() method since we are sending a POST request. The two arguments we pass are url and the data dictionary.

  • pastebin_url = r.text

    In response, the server processes the data sent to it and sends the pastebin URL of your source_code which can be simply accessed by r.text .

requests.post method could be used for many other tasks as well like filling and submitting the web forms, posting on your FB timeline using the Facebook Graph API, etc.

Here are some important points to ponder upon:

  • When the method is GET, all form data is encoded into the URL, appended to the action URL as query string parameters. With POST, form data appears within the message body of the HTTP request.
  • In GET method, the parameter data is limited to what we can stuff into the request line (URL). Safest to use less than 2K of parameters, some servers handle up to 64K.No such problem in POST method since we send data in message body of the HTTP request, not the URL.
  • Only ASCII characters are allowed for data to be sent in GET method.There is no such restriction in POST method.
  • GET is less secure compared to POST because data sent is part of the URL. So, GET method should not be used when sending passwords or other sensitive information.

This blog is contributed by Nikhil Kumar. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Article Tags :

www.geeksforgeeks.org


You May Also Like

About the Author: admind

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Этот сайт использует Akismet для борьбы со спамом. Узнайте, как обрабатываются ваши данные комментариев.