Client http python: HTTP client example — Asyncio Documentation 0.0 documentation

Содержание

Использование HttpServer в Python как простой HTTP-сервер

Этот модуль служит очень быстрым и простым способом запустить локальный Http-сервер в вашей сети.

Ранее в Python 2.7 этот модуль назывался HttpServer . Но в Python3 этот модуль был объединен с модулем http.server. Давайте начнем и запустим наш собственный Http-сервер.

Импорт модуля httpserver

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

import http.server

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

Запуск HTTP-сервера

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

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

python -m http. server 9000

Здесь мы запускаем наш локальный Http-сервер на порту 9000.

Подключение

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

Зайдите на сервер и узнайте IP-адрес сервера с помощью arp -a в Windows или ip -a | grep inet в Linux.
На удаленном клиенте просто введите http://IP_ADDRESS:9000/ в своем браузере.

Выход

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

Запуск HttpServer, который обслуживает настраиваемый файл index.html

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

Например, мы будем запускать собственный Http-сервер, который использует http.server и socketserver для связи TCP.

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

# server.py
import http.server # Our http server handler for http requests
import socketserver # Establish the TCP Socket connections

PORT = 9000

class MyHttpRequestHandler(http.server.SimpleHTTPRequestHandler):
    def do_GET(self):
        self.path = 'index.html'
        return http.server.SimpleHTTPRequestHandler.do_GET(self)

Handler = MyHttpRequestHandler

with socketserver.TCPServer(("", PORT), Handler) as httpd:
    print("Http Server Serving at port", PORT)
    httpd.serve_forever()

Если вы назовете это как server.py , вы можете запустить http-сервер, используя:

python server.py

Поскольку мы определили нашу пользовательскую функцию do_GET(), мы можем обслуживать HTML-файл домашней страницы, используя наш сервер, которым в данном случае является index. html. Также, если сервер работает в вашей системе, вы можете напрямую получить доступ к серверу, используя localhost: <portnumber> вместо использования IP.

Как создавать API-запросы в Python (используем Requests и aiohttp)

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

Один из аспектов, влияющих на все три эти специализации, — мощные преимущества API. Сбор данных и подключение к внешним сервисам — важная часть любого языка. В этой статье мы рассмотрим основные библиотеки для выполнения HTTP-запросов, а также некоторые распространенные варианты их использования, позволяющие подключаться к API в Python. Но сначала следует ответить на один важный вопрос:

Подходит ли Python для API?

Это может показаться странным вопросом, но, учитывая засилье в вебе Node. js и Ruby, вы можете подумать, что Python не так хорош для создания API-запросов. Но это не так. На самом деле Python тоже давно присутствует в вебе, особенно если принять во внимание его библиотеки Flask и Django.

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

Библиотека Requests

Requests — это широко известная библиотека, которую разработчики используют для выполнения API-запросов в Python. Она предлагает интерфейс для синхронного выполнения HTTP-запросов. Давайте рассмотрим несколько распространенных типов запросов, которые вы можете делать с помощью этой библиотеки. В дальнейшем мы будем предполагать, что эта библиотека у вас уже установлена. Для установки вы можете использовать документацию библиотеки, но сам процесс очень прост.

pip install requests

Библиотеку также нужно импортировать:

import requests

Распространенные типы API-запросов в библиотеке Requests

Наиболее простой GET-запрос интуитивно понятен:

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

По аналогии с приведенным выше примером метода get, библиотека Requests предлагает методы для всех HTTP-действий, а именно: POST, PUT, DELETE, HEAD и OPTIONS.

Этот запрос был довольно прост. Давайте теперь рассмотрим более сложные запросы. Часто документация по API требует, чтобы вы передавали параметры запроса в конкретную конечную точку. Чтобы это сделать, мы можем передать параметры запроса в метод get в качестве второго аргумента.

response = requests. get('https://example.com', params={'name': 'Bearer'})

Переменная response содержит данные, возвращаемые API в качестве ответа на наш запрос. Есть три основных способа доступа к этим данным:

в виде текста, при помощи response.text,
в виде байт-кода, при помощи response.content,
в формате JSON, при помощи response.json().

Также можно получить сырые данные при помощи response.raw.

Помимо тела самого ответа, мы также можем получить доступ к коду состояния — при помощи response.status_code, к заголовкам — при помощи response.headers, и так далее. Полный список атрибутов и методов, доступных для Response, вы можете найти в документации requests.Response.

Помимо параметров запроса, мы также можем передавать в запрос заголовки:

response = requests. get('https://example.com, headers={'example-header': 'Bearer'})

Здесь мы передаем в качестве аргумента заголовок в виде словаря Python.

Последний тип API-запроса, который мы сейчас рассмотрим — это полнофункциональный POST-запрос с аутентификацией. Этот пример объединит два предыдущих, здесь мы передадим в качестве аргументов и заголовок, и данные.

url = 'https://example.com'
headers = {'Authorization': 'Bearer example-auth-code'}
payload = {'name':'Mark', email: '[email protected]'}

response = requests.post(url, headers=headers, data=payload)

Здесь мы отправляем данные из переменной payload в формате словаря Python. Для большинства современных API нам часто требуется отправлять данные в формате JSON. В следующем примере мы используем встроенный json-конвертер из библиотеки Requests.

url = 'https://example.com'
headers = {'Authorization': 'Bearer example-auth-code'}
payload = {'name':'Mark', email: '[email protected]'}

response = requests.post(url, headers=headers, json=payload)

Это преобразует содержимое переменной payload в формат JSON, а также автоматически переведет в этот тип данных заголовки из переменной headers.

Библиотека Requests отлично подходит для выполнения синхронных API-запросов, но иногда вашему приложению нужно выполнять асинхронные запросы. Для этого мы можем использовать асинхронную HTTP-библиотеку aiohttp.

Библиотека aiohttp

Для выполнения асинхронных HTTP-запросов вам необходимо воспользоваться некоторыми новыми функциями Python 3. Хотя у библиотеки Requests есть различные дополнения и плагины для асинхронного программирования, одной из наиболее популярных библиотек для этого является библиотека aiohttp. Используя ее вместе с библиотекой acincio, мы можем эффективно исполнять асинхронные запросы. Код будет немного сложнее, но асинхронные запросы сами по себе предоставляют большую свободу действий.

Для начала установим библиотеку aiohttp:

pip install aiohttp

Распространенные типы API-запросов в библиотеке aiohttp

Как и раньше, начнем с GET-запроса. Для начала импортируем обе библиотеки и определим функцию main() как асинхронную.

import asyncio #  [1]
import aiohttp

async def main(): # [2]
    async with aiohttp.ClientSession() as session: # [3]
    async with session.get('http://example.com') as resp: # [4]
        response = await resp.read() # [5]
        print(response)

asyncio.run(main()) # [6]

В этом коде мы выполняем следующие шаги:

Импортируем необходимые библиотеки.
Определяем функцию main как асинхронную.
Устанавливаем сессию ClientSession из aiohttp.
Используем данную сессию для выполнения HTTP GET-запроса.
Далее дожидаемся ответа и выводим его на экран.
Наконец, используем метод run из библиотеки asyncio для запуска асинхронной функции main().

Если вы никогда раньше не работали с асинхронными методами в Python, это может показаться странным и сложным по сравнению с предыдущими примерами. Создатели библиотеки aiohttp рекомендуют устанавливать один сеанс для каждого приложения и открывать / закрывать соединения в этом сеансе. Чтобы сделать наши примеры самодостаточными, мы составили примеры в менее эффективном формате.

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

# . ..

async def main():
    async with aiohttp.ClientSession() as session:
        async with session.post('http://example.com',
            headers={'Authorization':'Bearer 123456', 'Content-Type':'application/json'},
            json={'title':'Try Bearer'}) as resp: # [1]

            response = await resp.json() # [2]
            print(response)

asyncio.run(main())

Между этим примером и предыдущим есть несколько различий:

В нашей сессии используется метод post, который передает заголовки и словари json вместе с URL-адресом.
Мы используем встроенный в библиотеку метод json из класса resp для анализа возвращенных данных в формате json.

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

Некоторые дополнительные библиотеки

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

httpx: данная библиотека поддерживает как синхронные, так и асинхронные запросы. Она также использует API-интерфейс, совместимый с библиотекой Requests, что значительно упрощает переход между ними. В настоящее время библиотека находится в стадии бета-тестирования, но за ее развитием стоит последить.
httpcore: интересный вариант, если вы сами создаете библиотеку. Эта библиотека низкоуровневая, поэтому вы можете создавать на нем свои собственные абстракции. Но если вам не нужна именно низкоуровневая библиотека, то сами создатели не рекомендуют ее использовать.
urllib3: мы должны упомянуть urllib3 хотя бы потому, что это базовая библиотека, на которой построена библиотека Requests и многие другие очень известные библиотеки (например pip). Хотя urllib3 и менее удобна для пользователя, чем некоторые высокоуровневые библиотеки, она мощна и проверена на практике. Если по какой-то причине вам нужно что-то с меньшим количеством абстракций, чем в библиотеке Requests, urllib3 будет хорошим вариантом.

Python: модуль requests

requests — HTTP библиотека Python. Ближайший аналог — urllib2.

Содержит в себе встроенную библиотеку urllib3.

Домашняя страница проекта — Requests: HTTP for Humans.

Установить requests можно спомощью PIP:

$ pip install requests
...
Installing collected packages: requests
Successfully installed requests-2.7.0

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

Создание подключения:

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

Теперь r является объектом Response:

>>> type(r)
<class 'requests.models.Response'>

>>> print(r.__doc__)
The :class:`Response <Response>` object, which contains a
    server's response to an HTTP request.

Таким образом мы можем выполнять все стандартные запросы — PUT, DELETE, HEAD and 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")

Передача аргументов в запросе

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

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

Данные были корректно обработа и переданы, что можно увидеть вызвав атрибут url объекта r:

>>> r. url
u'http://httpbin.org/get?key2=value2&key1=value1'

Учтите, что любое значение в словаре, которое является Null не будет передано.

Что бы передать список объектов в виде значения — вы должны добавить квадратые скобки [] к ключу:

>>> payload = {'key1': 'value1', 'key2[]': ['value2', 'value3']}
>>> r = requests.get("http://httpbin.org/get", params=payload)
>>> r.url
u'http://httpbin.org/get?key1=value1&key2%5B%5D=value2&key2%5B%5D=value3'

Содержимое объекта `response`

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

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

Необработанное содержимое объекта `response`

В случае, если вам необходимо получить необработанные (raw) данные от сервера — вы можете воспользоваться представлением raw. При этом — убедитесь, что параметр stream для Requests установлен в True:

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

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

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

Изменение заголовков

Если вы хотите добавить какие-то заголовки в HTTP-запрос — просто доавбьте передачу словаря с ними в параметр headers:

>>> import json
>>> url = 'https://api.github.com/some/endpoint'
>>> headers = {'user-agent': 'my-app/0.0.1'}
>>> r = requests.get(url, headers=headers)

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

Возможно, вам требуется отправлять более сложные запросы, например — данные форм, как формы в HTML. Что бы сделать это — просто передайте словарь с данными параметру data:

>>> payload = {'key1': 'value1', 'key2': 'value2'}
>>> headers = {'user-agent': 'rtfm/0.0.1'}
>>> r = requests.post("http://httpbin.org/post", data=payload, headers=headers)
>>> print(r.text)
{
  "args": {},
  "data": "",
  "files": {},
  "form": {
    "key1": "value1",
    "key2": "value2"
  },
  "headers": {
    "Accept": "*/*",
    "Accept-Encoding": "gzip, deflate",
    "Content-Length": "23",
    "Content-Type": "application/x-www-form-urlencoded",
    "Host": "httpbin.org",
    "User-Agent": "rtfm/0.0.1"
  },
  "json": null,
  "origin": "194.***.***.69",
  "url": "http://httpbin.org/post"
}

Иногда вам может потребоваться передать данные не в виде формы. Если вы передадите строку вместо словаря — данные будут добдавлены напрямую.

Например, GitHub API v3 принимает POST/PATCH в формате JSON:

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

`POST` для файлов составной кодировки

С помощью 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>"
  },
  ...
}

Вы так же можете указать имя файла, тип контента и заголовки явным образом:

>>> 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,send\nanother,row,to,send\n"
  },
  ...
}

Коды состояний в `requests`

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

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

Кроме того, в requests имеются специальный способ проверки кодов состояния:

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

Для работы с кодами ошибок — можно использовать метод 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 "<stdin>", line 1, in <module>
  File "/usr/lib/python2.7/site-packages/requests/models.py", line 851, in raise_for_status
    raise HTTPError(http_error_msg, response=self)
requests.exceptions.HTTPError: 404 Client Error: NOT FOUND

И использовать его в конструкции try/except:

#!/usr/bin/env python

import requests

bad_r = requests.get('http://httpbin.org/status/404')

try:
    bad_r.raise_for_status()
except requests.exceptions.HTTPError as e:
    print('ERROR: %s' % e)

$ ./req.py
ERROR: 404 Client Error: NOT FOUND

Заголовки в `requests`

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

>>> r.headers
{'content-length': '284', 'server': 'nginx', 'connection': 'keep-alive', 'access-control-allow-credentials': 'true', 'date': 'Tue, 02 Jun 2015 10:11:57 GMT', 'access-control-allow-origin': '*', 'content-type': 'application/json'}

Или получить только отдельное поле заголовка:

>>> r.headers['server']
'nginx'

Таймауты

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

>>> requests.get('http://github.com', timeout=0.001)
...
requests.exceptions.ConnectTimeout: HTTPConnectionPool(host='github.com', port=80): Max retries exceeded with url: / (Caused by ConnectTimeoutError(<requests.packages.urllib3.connection.HTTPConnection object at 0x6ffff676e50>, 'Connection to github.com timed out. (connect timeout=0.001)'))

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

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

В случае некорректных заголовков HTTP — будет вызвано исключение HTTPError.

В случае таймаута — исключение Timeout.

Оригинал статьи: http://docs.python-requests.org

Очень простой чат(клиент/сервер) на Python. » Tapen.ru

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

Постановка задачи.

Написать сервер для приема сообщений от клиента и отправки сообщений всем остальным клиентов. Будем использовать протокол TCP/IP.
Собственно сам клиент. Который коннектится к серверу по TCP/IP. Отправляет и получает сообщения от сервера.
Ну и реализуем какое нибудь простое шифрование. Что бы сообщения могли читать только клиенты.

Часть первая. Сервер.

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

import socket

Создадим сам сокет:

sock = socket.socket (socket.AF_INET, socket.SOCK_DGRAM)

socket.AF_INET — для сокета используем IPv4 . socket.SOCK_DGRAM — тип сокета. Датаграммный сокет — это сокет, предназначенный для передачи данных в виде отдельных сообщений (датаграмм). По сравнению с потоковым сокетом, обмен данными происходит быстрее, но является ненадёжным: сообщения могут теряться в пути, дублироваться и переупорядочиваться. Датаграммный сокет допускает передачу сообщения нескольким получателям (multicasting) и широковещательную передачу (broadcasting).

Теперь свяжем сокет с адресом(интерфейсом) и портом :

sock.bind (('',5050))

Пусты кавычки значат что сокет слушает все доступные интерфейсы.

Теперь нам надо как то принимать сообщения. На совершенно все равно от кого и что получать. Наша задача получить и отправить остальным известным клиентам. По этому мы будем использовать функцию socket.recvfrom(bufsize) которая нам вернет данные и адрес сокета с которого получены эти данные.

data , addres = sock.recvfrom(1024)  # Буфер в байтах

Для отправки данных будем использовать функцию socket.sendto( bytes, address ) :

 sock.sendto(data,addres)

Итог у нас такой :

import socket
sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
sock.bind (('94.250.252.115',5050))
client = [] # Массив где храним адреса клиентов
print ('Start Server')
while 1 :
         data , addres = sock.recvfrom(1024)
         print (addres[0], addres[1])
         if  addres not in client : 
                 client.append(addres)# Если такова клиента нету , то добавить
         for clients in client :
                 if clients == adress : 
                     continue # Не отправлять данные клиенту который их прислал
                 sock.sendto(data,clients)

Клиентская часть.

С клиентом немного все посложней. Так как это чат, нам надо получать и отправлять сообщения одновременно. Или не зависимо друг от друга. Для этого нам потребуется многопоточное выполнение нашего кода. Для этого мы будем использовать модуль threading

import threading

Первым делом создадим функцию которая будет получать сообщения от сервера:

def read_sok():
     while 1 :
         data = sor.recv(1024)
         print(data.decode('utf-8'))

Теперь нам надо создать поток и запустить в нем эту функцию:

potok = threading.Thread(target= read_sok)
potok.start()

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

import socket
import threading
def read_sok():
     while 1 :
         data = sor.recv(1024)
         print(data.decode('utf-8'))
 server = '192.168.0.1', 5050  # Данные сервера
 alias = input() # Вводим наш псевдоним
 sor = socket.socket(socket.key)
mensahe = crypt

Я не рассчитываю на уникальность материала, сам учусь ) Строго не судите. Подсказки и доработки приветствуются.

http.client метод запроса в Python 3

Когда я запускаю этот код:

import http.client
hR = ["/index.html"]
conn = http.client.HTTPConnection("www.python.org", 80)
conn.connect()
conn.request("GET", hR)
response = conn.getresponse()
data = response.read()
print (data)
conn.close()

Я получаю следующую ошибку:

Traceback (most recent call last):
  File "C:\Python32\files\fcon.py", line 5, in <module>
    conn.request("GET", hR)
  File "C:\Python32\lib\http\client.py", line 964, in request
    self._send_request(method, url, body, headers)
  File "C:\Python32\lib\http\client.py", line 992, in _send_request
    self.putrequest(method, url, **skips)
  File "C:\Python32\lib\http\client.py", line 877, in putrequest
    if url.startswith('http'):
AttributeError: 'list' object has no attribute 'startswith'

Кроме того, когда я изменяю URL в строке 3 на «http://python.org», я получаю другую ошибку:

Traceback (most recent call last):
  File "C:\Python32\files\fcon.py", line 4, in <module>
    conn.connect()
  File "C:\Python32\lib\http\client.py", line 721, in connect
    self.timeout, self.source_address)
  File "C:\Python32\lib\socket.py", line 380, in create_connection
    for res in getaddrinfo(host, port, 0, SOCK_STREAM):
socket.gaierror: [Errno 11001] getaddrinfo failed

python-3.x

Поделиться

Источник

Shivam Kotwalia

10 июля 2014 в 08:17

1 ответ

в чем разница между ‘http.Client’ и ‘&http.Client’ в go версии 1.12
Я создаю запрос http по ‘net/http’, официальному документу use &http.Client{} , но я пытаюсь удалить & может работать нормально. client := &http.Client{} client := http.Client{} В чем разница между двумя путями? Лучшие практики есть?
Selenium-нет модуля с именем http.client
Я только что установил Selenium (из исходного кода) для Python 2.7. Когда я пытаюсь import selenium , я получаю следующую ошибку: Traceback (most recent call last): File <stdin>, line 1, in <module> File C:\Python27\lib\site-packages\selenium-2.25.0-py2.7.egg\selenium\__init__.py, line…

Первое сообщение об ошибке говорит вам, что hR должен быть не список, а строка, это будет работать:

import http.client
hR = "/index.html"
conn = http.client.HTTPConnection("www.python.org", 80)
conn.connect()
conn.request("GET", hR)
response = conn.getresponse()
data = response.read()
print (data)
conn.close()

Однако вы не увидите никаких данных, потому что python.org отвечает только с http 301 ответами, перенаправленными на его страницу https, которая http.client автоматически не следует.

Вторая ошибка, которую вы получаете, потому что http://www.python.org не является допустимым именем хоста, www.python.org была здесь правильной.

http.client -это довольно низкоуровневый API, вы должны рассмотреть возможность использования вместо него urllib.request или даже лучше библиотеки requests .

Поделиться

mata

12 июля 2014 в 09:59

http.client — клиент протокола HTTP — документация Python 3.8.6

Исходный код: Lib / http / client.py

Этот модуль определяет классы, которые реализуют клиентскую сторону HTTP и
Протоколы HTTPS. Обычно он не используется напрямую — модуль
urllib.request использует его для обработки URL-адресов, использующих HTTP и HTTPS.

См. Также

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

Примечание

Поддержка

HTTPS доступна только в том случае, если Python был скомпилирован с поддержкой SSL.
(через модуль ssl ).

В модуле предусмотрены следующие классы:

класс http.client. HTTPConnection ( host , port = None , [ timeout ,] source_address = None , blockize = 8192 )

Экземпляр HTTPConnection представляет одну транзакцию с HTTP
сервер.Он должен быть создан, передав ему хост и необязательный порт.
число. Если номер порта не передан, порт извлекается из хоста.
строка, если она имеет вид хост: порт , иначе порт HTTP по умолчанию (80)
используемый. Если указан необязательный параметр тайм-аут , блокировка
операции (например, попытки подключения) будут отключены по истечении этого времени
(если он не указан, используется глобальная настройка времени ожидания по умолчанию).
Необязательный source_address параметр может быть кортежем (хост, порт)
для использования в качестве адреса источника, с которого выполняется HTTP-соединение.Необязательный параметр blockize устанавливает размер буфера в байтах для
отправка тела сообщения в виде файла.

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

 >>> h2 = http.client.HTTPConnection ('www.python.org')
>>> h3 = http.client.HTTPConnection ('www.python.org:80')
>>> h4 = http.client.HTTPConnection ('www.python.org', 80)
>>> h5 = http.client.HTTPConnection ('www.python.org ', 80, тайм-аут = 10)

Изменено в версии 3.2: добавлен source_address .

Изменено в версии 3.4: удален параметр strict . «Простые ответы» в стиле HTTP 0.9:
больше не поддерживается.

Изменено в версии 3.7: добавлен параметр blockize .

класс http.client. HTTPSConnection

Python Tutorial: Network Programming — Server & Client A: Basics

Сетевое программирование — сервер и клиент A: основы

Боготобого.com поиск по сайту:

Сетевое программирование

Посетите http://www.bogotobogo.com/cplusplus/sockets_server_client.php, чтобы ознакомиться с общей концепцией сетевого программирования, TCP / IP /, сокетов и т. Д.

Простая розетка

В следующем коде сервер отправляет клиенту строку текущего времени:

# server.py
импортный сокет
время импорта

# создать объект сокета
serversocket = socket.socket (
разъем.AF_INET, socket.SOCK_STREAM)

# получить имя локальной машины
host = socket.gethostname ()

порт = 9999

# привязать к порту
serversocket.bind ((хост, порт))

# поставить в очередь до 5 запросов
serversocket.listen (5)

в то время как True:
    # установить соединение
    clientocket, addr = serversocket.accept ()

    print ("Установлено соединение от% s"% str (addr))
    currentTime = время.ctime (time.time ()) + "\ r \ n"
    clientocket.send (currentTime.encode ('ascii'))
    clientocket.close ()

Вот краткое изложение основных функций сокета — Сетевой интерфейс низкого уровня:

socket.socket () : Создайте новый сокет, используя указанное семейство адресов, тип сокета и номер протокола.
socket.bind (адрес) : привязать сокет к адресу .
socket.listen (backlog) : прослушивание подключений к сокету.Аргумент backlog указывает максимальное количество подключений в очереди и должен быть не менее 0; максимальное значение зависит от системы (обычно 5), минимальное значение устанавливается равным 0.
socket.accept () : возвращаемое значение — это пара (conn, address) , где conn — новый объект сокета, используемый для отправки и получения данных в соединении, а адрес — это адрес, привязанный к разъем на другом конце соединения.
На этапе accept () создается новый сокет, отличный от названного сокета.Этот новый сокет используется исключительно для связи с этим конкретным клиентом.
Для TCP-серверов объект сокета, используемый для получения соединений, не совпадает с тем же сокетом, который используется для последующего обмена данными с клиентом. В частности, системный вызов accept () возвращает новый объект сокета, который фактически используется для соединения. Это позволяет серверу одновременно управлять соединениями от большого количества клиентов.
socket.send (байты [, флаги]) : Отправить данные в сокет.Сокет должен быть подключен к удаленному сокету. Возвращает количество отправленных байтов. Приложения несут ответственность за проверку того, что все данные были отправлены; если была передана только часть данных, приложению необходимо попытаться доставить оставшиеся данные.
socket.colse () : Отметьте гнездо как закрытое. все будущие операции с объектом сокета завершатся ошибкой. Удаленный конец не будет получать больше данных (после того, как данные из очереди будут сброшены). Сокеты автоматически закрываются, когда они собираются сборщиком мусора, но рекомендуется явно close () их.

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

# client.py
импортный сокет

# создать объект сокета
s = socket.socket (socket.AF_INET, socket.SOCK_STREAM)

# получить имя локальной машины
host = socket.gethostname ()

порт = 9999

# подключение к имени хоста на порту.
s.connect ((хост, порт))

# Принимаем не более 1024 байтов
tm = s.recv (1024)

s.close ()

print ("Время получено от сервера% s"% tm.decode ('ascii'))

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

$ python server.py &
Получил связь от ('127.0,0.1 ', 54597)

$ python client.py
Время, полученное с сервера: среда, 29 января, 19:14:15 2014 г.

Примечание от http://docs.python.org/2/howto/sockets.html:

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

«Если вы все же решите использовать сокеты , привяжите сокет server к localhost.На большинстве платформ это потребует сокращения нескольких уровней сетевого кода и будет намного быстрее ».

В Python 3 все строки Unicode . Для получения дополнительной информации посетите страницу «Кодировка символов».
Итак, если какая-либо текстовая строка должна быть отправлена по сети, она должна быть
закодировано, поэтому сервер использует метод encode (‘ascii’) для данных, которые он
передает. Аналогичным образом, когда клиент получает сетевые данные, эти данные сначала принимаются как сырые.
незакодированные байты.Если вы распечатаете его или попытаетесь обработать как текст, мы вряд ли получим
что мы ожидали. Вместо этого нам нужно сначала его декодировать, поэтому клиентский код
используя decode (‘ascii’) по результату.

Эхо-сервер

Это эхо-сервер: сервер, который возвращает все полученные данные клиенту, который их отправил.

Сервер:

# echo_server.py
импортный сокет

host = '' # Символьное имя, обозначающее все доступные интерфейсы
port = 12345 # Произвольный непривилегированный порт
s = розетка.сокет (socket.AF_INET, socket.SOCK_STREAM)
s.bind ((хост, порт))
s.listen (1)
conn, addr = s.accept ()
print ('Подключено', адрес)
в то время как True:
    data = conn.recv (1024)
    если не данные: перерыв
    conn.sendall (данные)
conn.close ()

Клиент:

# echo_client.py
импортный сокет

host = socket.gethostname ()
port = 12345 # Тот же порт, что и сервер
s = socket.socket (socket.AF_INET, socket.SOCK_STREAM)
s.connect ((хост, порт))
s.sendall (привет, мир)
data = s.recv (1024)
s.close ()
print ('Получено', repr (данные))

Обратите внимание, что сервер sendall () / recv () выполняет не тот сокет, который он прослушивает, а новый сокет, возвращаемый функцией accept () .

$ python echo_server.py
('Подключено', ('127.0.0.1', 57750))

$ python echo_client.py
("Получено", "" Привет, мир "")

Сетевое программирование — сервер и клиент A: основы

Сетевое программирование — сервер и клиент B: передача файлов

Сетевое программирование II — чат-сервер и клиент

Сетевое программирование III — SocketServer

Сетевое программирование IV — Асинхронный запрос SocketServer

Дом Python

Введение

Запуск программ Python (os, sys, импорт)

Модули и IDLE (импорт, перезагрузка, выполнение)

Типы объектов — числа, строки и ничего

Строки — escape-последовательность, необработанная строка и нарезка

Строки — Методы

Форматирование строк — выражения и вызовы методов

Файлы и ос.путь

Рекурсивный обход каталогов

Модуль подпроцесса

Регулярные выражения в Python

Типы объектов — списки

Типы объектов — словари и кортежи

Функции def, * args, ** kargs

Функции лямбда

Встроенные функции

сопоставить, отфильтровать и уменьшить

Декораторы

Понимание списка

Наборы (объединение / пересечение) и itertools — коэффициент Жаккара и шинглинг для проверки плагиата

Хеширование (хеш-таблицы и хеш-библиотека)

Понимание словаря с помощью zip

Ключевое слово yield

Генератор функций и выражений

Генератор

.send () метод

Итераторы

Классы и экземпляры (__init__, __call__ и т. Д.)

if__name__ == ‘__main__’

argparse

Исключения

@static метод против метода класса

Частные атрибуты и частные методы

бита, байта, битовая строка и constBitStream

json.dump (s) и json.load (s)

Сериализация объектов Python — рассол и json

Сериализация объектов Python — yaml и json

Приоритетная очередь и структура данных очереди кучи

Данные графика Stru

Выполнение 1 миллиона запросов с помощью python-aiohttp

В этом посте я хотел бы протестировать ограничения python aiohttp и проверить его производительность в
количество запросов в минуту.Всем известно, что асинхронный код выполняет
лучше применительно к сетевым операциям, но все же интересно проверить это
предположение и понять, как именно это лучше и почему лучше. Я иду
чтобы проверить это, сделав 1 миллион запросов с помощью клиента aiohttp. Сколько запросов в минуту будет делать aiohttp?
Какие исключения и сбои можно ожидать при попытке сделать такой объем
запросов с очень примитивными скриптами? Какие основные подводные камни вам нужны
о чем думать, когда пытаешься сделать такой объем запросов?

Привет asyncio / aiohttp

Асинхронное программирование — это непросто.Это непросто, потому что использование обратных вызовов и мышление с точки зрения событий
а обработчики событий требуют больше усилий, чем обычное синхронное программирование. Но
это также сложно, потому что asyncio все еще относительно новый и их мало
сообщения в блогах, руководства по этому поводу. Официальные документы
очень краткие и содержат только базовые примеры. Есть несколько вопросов о переполнении стека
но не так много
всего 410 на момент написания (сравните с 2 585 вопросами с пометкой «скрученный»)
Есть несколько хороших сообщений в блогах и статей об asyncio.
там, вот такие,
это, это или, возможно, даже это
или это.

Чтобы упростить задачу, давайте начнем с основ — простого HTTP hello world —
просто выполняя GET и получая один-единственный HTTP-ответ.

В синхронном мире вы просто делаете:

  запросов на импорт

def привет ():
    вернуть requests.get ("http://httpbin.org/get")

print (hello ())

Как это выглядит в aiohttp?

  #! / Usr / local / bin / python3.5
импортировать asyncio
из aiohttp import ClientSession

async def привет (URL):
    async с ClientSession () в качестве сеанса:
        асинхронный с сеансом.получить (url) в качестве ответа:
            response = ждать ответа.read ()
            печать (ответ)

цикл = asyncio.get_event_loop ()

loop.run_until_complete (привет ("http://httpbin.org/headers"))

хммм, похоже, мне пришлось написать много кода для такой базовой задачи … Есть «async def» и «async with» и здесь два «ждут». Это
на первый взгляд кажется действительно запутанным, давайте попробуем объяснить это.

Вы делаете свою функцию асинхронной, используя ключевое слово async перед определением функции и используя ожидание
ключевое слово.На самом деле наша функция hello () выполняет две асинхронные операции. Первый
он получает ответ асинхронно, а затем асинхронно читает тело ответа.

Программа клиент-сервер Python с использованием модуля сокета

импортная розетка

# Создание серверного сокета

serverSocket = socket.socket ()

print («Серверный сокет создан»)

# Свяжите сокет сервера с IP и портом

ip = «127.0,0.1 «

порт = 35491

serverSocket.bind ((ip, порт))

print («Серверный сокет связан с ip {} port {}». Format (ip, port))

# Заставить сервер прослушивать входящие соединения

serverSocket.listen ()

# Входящие подключения к серверу «по одному»

количество = 0

, а (Истина):

(clientConnection, clientAddress) = serverSocket.accept ()

count = count + 1

print («На данный момент принято {} подключений» .format (count))

# чтение из клиентского соединения

, а (Истина):

данные = clientConnection.recv (1024)

печать (данные)

если (данные! = B »):

msg1 = «Привет, клиент! Прочтите все, что вы отправили»

сообщение1Bytes = str.кодировать (сообщение1)

msg2 = «Сейчас я закрою ваше соединение»

msg2Bytes = str.encode (msg2)

clientConnection.send (msg1Bytes)

clientConnection.send (msg2Bytes)

print («Соединение закрыто»)

перерыв

Учебное пособие по клиенту и серверу

UDP на Python

В этом руководстве я покажу вам, как именно вы можете настроить свой собственный чат-сервер UDP с помощью CPython 3.3 и модуль Python Socket. Конечным продуктом будет сервер, который прослушивает все соединения и сообщения через определенный порт и распечатывает любые сообщения на консоль. В будущем это может быть расширено, чтобы создать чат-сервер, который впоследствии будет транслировать любые полученные сообщения всем сторонам, ожидающим ответов.

Преимущества UDP в программировании игр

UDP или протокол пользовательских дейтаграмм — это протокол без установления соединения, который подходит для приложений, которым требуется эффективный обмен данными, которым не нужно беспокоиться о потере пакетов.Для игровых приложений это, как правило, идеальный протокол из-за меньших накладных расходов по сравнению с TCP. Обычно игры отправляют и получают тысячи пакетов в секунду, которые содержат такую информацию, как здоровье, местонахождение, направление и т. Д. Противостоящих игроков. Теперь, если один из этих пакетов должен был быть отброшен во время передачи, то это не слишком критично для игры, и в худшем случае игрок дергается на долю секунды во время игры.

Реализация клиента

Для начала нам нужно будет импортировать модуль python сокета, это можно сделать так:

Как только мы получим это, нам нужно объявить IP-адрес, на который мы будем пытаться отправлять наши UDP-сообщения, а также номер порта.Этот номер порта является произвольным, но убедитесь, что вы не используете уже занятый сокет.

  UDP_IP_ADDRESS = "127.0.0.1"
UDP_PORT_NO = 6789
Message = "Привет, сервер"

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

  clientSock = socket.socket (socket.AF_INET, socket.SOCK_DGRAM)

И, наконец, как только мы построили наш новый сокет, пришло время написать код, который будет отправлять наше UDP-сообщение:

  clientSock.sendto (Сообщение, (UDP_IP_ADDRESS, UDP_PORT_NO))

Внедрение сервера

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

  ## Снова импортируем необходимый модуль python сокета
импортный сокет
## Здесь мы определяем IP-адрес UDP, а также номер порта, который у нас есть
## уже определен в клиентском скрипте Python.UDP_IP_ADDRESS = "127.0.0.1"
UDP_PORT_NO = 6789

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

  ## объявить наш серверный сокет, на котором
## мы будем слушать сообщения UDP
serverSock = socket.socket (socket.AF_INET, socket.SOCK_DGRAM)
## Одно отличие состоит в том, что нам нужно будет привязать наш объявленный IP-адрес
## и номер порта для нашего недавно объявленного serverSock
serverSock.привязать ((UDP_IP_ADDRESS, UDP_PORT_NO))

И, наконец, как только мы создали наш серверный сокет, нам нужно написать код, который будет держать наш скрипт непрерывно прослушивающим этот сокет до его завершения. Это принимает форму простого цикла while, например:

 , а True:
    данные, адрес = serverSock.recvfrom (1024)
    печать "Сообщение:", данные