One place for hosting & domains


      Getting Started With Python Requests – GET Requests

      In many web apps, it’s normal to connect to various third-party services by using APIs. When you use these APIs you can get access to data like weather information, sports scores, movie listings, tweets, search engine results, and pictures. You can also use APIs to add functionality to your app. Examples of these are payments, scheduling, emails, translations, maps, and file transfers. If you were to create any of those on your own it would take a ton of time, but with APIs, it can take only minutes to connect to one and access its features and data.

      In this article, I’m going to talk about the Python Requests library, which allows you to send HTTP requests in Python.

      And since using an API is simply sending HTTP requests and receiving responses, Requests allows you to use APIs in Python. I’ll demonstrate the use of a language translation API here so you can see an example of how it works so you can potentially use it in your own apps.

      Quick Overview of HTTP Requests

      HTTP requests are how the web works. Every time you navigate to a web page, your browser makes multiple requests to the web page’s server. The server then responds with all the data necessary to render the page, and your browser then actually renders the page so you can see it.

      The generic process is this: a client (like a browser or Python script using Requests) will send some data to a URL, and then the server located at the URL will read the data, decide what to do with it, and return a response to the client. Finally, the client can decide what to do with the data in the response.

      Part of the data the client sends in a request is the request method. Some common request methods are GET, POST, and PUT. GET requests are normally for reading data only without making a change to something, while POST and PUT requests generally are for modifying data on the server. So for example, the Stripe API allows you to use POST requests to create a new charge so a user can purchase something from your app.

      This article will cover GET requests only because we won’t be modifying any data on a server.

      When sending a request from a Python script or inside a web app, you, the developer, gets to decide what gets sent in each request and what to do with the response. So let’s explore that by first sending a request to and then by using a language translation API.

      Install Python Requests

      Before we can do anything, we need to install the library. So let’s go ahead and install requests using pip. It’s a good idea to create a virtual environment first if you don’t already have one.

      pip install requests

      Our First Request

      To start, let’s use Requests for something simple: requesting the site. Create a file called and add the following code to it. In this article, we won’t have much code to work with, so when something changes you can just update the existing code instead of adding new lines.

      import requests
      res = requests.get('')

      So all this code is doing is sending a GET request to This is the same type of request your browser sent to view this page, but the only difference is that Requests can’t actually render the HTML, so instead you will just get the raw HTML and the other response information.

      We’re using the .get() function here, but Requests allows you to use other functions like .post() and .put() to send those requests as well.

      You can run it by executing the file.


      And here’s what you get in return:

      Status Codes

      The first thing we can do is check the status code. HTTP codes range from the 1XX to 5XX. Common status codes that you have probably seen are 200, 404, and 500.

      Here’s a quick overview of what each status code means:

      • 1XX – Information
      • 2XX – Success
      • 3XX – Redirect
      • 4XX – Client Error (you messed up)
      • 5XX – Server Error (they messed up)

      Generally, what you’re looking for when you perform your own requests are status codes in the 200s.

      Requests recognizes that 4XX and 5XX status codes are errors, so if those status codes get returned, the response object from the request evaluates to False.

      You can test if a request responded successfully by simply checking the response for truth. For example:

      if res:
          print('Response OK')
          print('Response Failed')

      The message “Response Failed” will only appear if a 400 or 500 status code returns. Try changing the URL to some nonsense to see the response fail with a 404.

      You can take a look at the status code directly by doing:


      This will show you the status code directly so you can check the number yourself.

      Another thing you can get from the response are the headers. You can take a look at them by using the headers dictionary on the response object.


      Headers are sent along with the request and returned in the response. Headers are used so both the client and the server know how to interpret the data that is being sent and received in the response/response.

      We see the various headers that are returned. A lot of times you won’t need to use the header information directly, but it’s there if you need it.

      The content type is usually the one you may need because it reveals the format of the data, for example HTML, JSON, PDF, text, etc. But the content type is normally handled by Requests so you can easily access the data that gets returned.

      Response Text

      And finally, if we take a look at res.text (this works for textual data, like a HTML page like we are viewing) we can see all the HTML needed to build the home page of Scotch. It won’t be rendered, but we see that it looks like it belongs to Scotch. If you saved this to a file and opened it, you would see something that resembled the Scotch site. In a real situation, multiple requests are made for a single web page to load things like images, scripts and stylesheets, so if you save only the HTML to a file, it won’t look anything like what the page looks like in your browser because only a single request was performed to get the HTML data.


      Using the Translate API

      So now let’s move on to something more interesting. We’ll use the Yandex Translate API to perform a request to translate some text to a different language.

      To use the API, first you need to sign up. After you sign up, go to the Translate API and create an API key. Once you have the API key, add it to your file as a constant. Here’s the link where you can do all those things:

      API_KEY = 'your yandex api key'

      The reason why we need an API key is so Yandex can authenticate us every time we want to use their API. The API key is probably the simplest form of authentication, because it’s simply added on to the end of the request URL when being sent.

      To know which URL we need to send to use the API, we can look at the documentation for Yandex here:

      If we look there, we’ll see all the information needed to use their Translate API to translate text.

      API documentation can be difficult to read at times, but in this case it’s simple. When we see a URL with ampersands (&), question marks (?), and equals signs (=), you can be sure that the URL is for GET requests. Those symbols specify the parameters that go along with the URL.

      Normally things in square brackets ([]) will be optional. In this case, format, options, and callback are optional, while the key, text, and lang are required for the request.

      And of course it’s easy to see the URL. So let’s add some code to send to that URL. You can replace the first request we created with this:

      res = requests.get(url)

      There are two ways we can add the parameters. We can either append it to the end of the URL directly, or we can have Requests do it for us. Having Requests do it for us is much easier.

      To do that, we can create a dictionary for our parameters. The three items we need are the key, the text, and the language.

      Let’s create the dictionary using the API key, ‘Hello’ for the text, and ‘en-es’ as the lang, which means we want to translate from English to Spanish.

      If you need to know any other language codes, you can look here: You are looking for the 639-1 column.

      We create a params dictionary by using the dict() function and passing in the keys and values we want in our dictionary.

      params = dict(key=API_KEY, text="Hello", lang='en-es')

      Now we take the parameters dictionary and pass it to the .get() function.

      res = requests.get(url, params=params)

      When we pass the parameters this way, Requests will go ahead and add the parameters to the URL for us.

      Now let’s add a print statement for the response text and view what gets returned in the response.


      We see three things. We see the status code, which is exactly the same status code of the response itself, we see the language that we specified, and we see the translated text inside of the list. So you should see ‘Hola’ for the translated text.

      Try again with en-fr as the language code, and you should see ‘Boujour’ in the response now.

      params = dict(key=API_KEY, text="Hello", lang='en-fr')

      Let’s take a look at the headers for this particular response.


      Obviously the headers should be different because we’re communicating with a different server, but in this case the content type is application/json instead of text/html. What this means that the data can be interpreted as JSON.

      When application/json is the content type of the response, we are able to have Requests convert the response to a dictionary and list so we can access the data easier.

      To have the data parsed as JSON, we use the .json() method on the response object.

      If you print it, you’ll see that the data looks the same, but the format is slightly different.

      json = res.json()

      The reason why it’s different is because it’s no longer plain text that you get from res.text. This time it’s a printed version of a dictionary.

      Let’s say we want to access the text. Since this is now a dictionary, we can use the text key.


      And now we only see the data for that one key. In this case we are looking at a list of one item, so if we wanted to get that text in the list directly, we can access it by the index.


      And now the only thing we see is the translated word.

      So of course if we change things in our parameters, we’ll get different results. Let’s change the text to be translated from Hello to Goodbye, change the target language back to Spanish, and send the request again.

      params = dict(key=API_KEY, text="Goodbye", lang='en-es')

      Try translating longer text in different languages and see what responses the API gives you.

      Translate API Error Cases

      Finally, we’ll take a look at an error case. Everything doesn’t always work, so we need to know when that happens.

      Try changing your API KEY by removing one character. When you do this your API key will no longer by valid. Then try sending a request.

      If you take a look at the status code, this is what you get:


      So when you are using the API, you’ll want to check if things are successful or not so you can handle the error cases according to the needs of your app.


      Here’s what we learned:

      • How HTTP requests work
      • The various status codes possible in a response
      • How to send requests and receive responses using the Python Requests library
      • How to use a language translation API to translate text
      • How to convert application/json content responses to dictionariesThat covers the basics of Requests in Python. Of course you can do so much more, but what I talked about in this article is the foundation of most requests. Things may change slightly depending on the circumstances, but the basic ideas will remain the same.

      If you want to do more, check out to see different APIs that are available, and try to use them with Python Requests.

      Source link

      Pasos iniciales para utilizar la biblioteca Requests de Python


      En muchas aplicaciones web, es habitual conectarse a varios servicios de terceros mediante API. Al utilizar estas API, puede acceder a datos como información meteorológica, resultados deportivos, listas de películas, tuits, resultados de motores de búsqueda e imágenes. También puede usar API para añadir funcionalidades a su aplicación. Entre los ejemplos se incluyen pagos, programaciones, correos electrónicos, traducciones, mapas y transferencias de archivos. Si tuviera que crear cualquiera de estos ejemplos por su cuenta, le tomaría muchísimo tiempo, pero con API pude tardar solo unos minutos en conectarse y acceder a sus características y datos.

      En este artículo, aprenderá acerca de la biblioteca Requests de Python, que le permite enviar solicitudes HTTP en Python.

      Además, dado que al usar una API se envían solicitudes HTTP y se reciben respuestas, Requests le permite usar API en Python. Demostraremos el uso de una API de traducción de idiomas para que pueda ver un ejemplo de su funcionamiento.

      Descripción general rápida de solicitudes HTTP

      La web funciona mediante solicitudes HTTP. Cada vez que navega a una página web, su navegador realiza varias solicitudes al servidor de esta. A continuación, el servidor responde con todos los datos necesarios para representar la página y, luego, su navegador la representa de modo que pueda verla.

      El proceso genérico es el siguiente: un cliente (como un navegador o una secuencia de comandos de Python que utilice Requests) enviará algunos datos a una URL y, luego, el servidor situado en la URL leerá los datos, decidirá qué hacer con ellos y mostrará una respuesta al cliente. Por último, el cliente puede decidir qué debe hacer con los datos de la respuesta.

      El método de solicitud está incluido en los datos que el cliente envía en una solicitud. Algunos métodos de solicitud frecuentes son GET, POST y PUT. Las solicitudes GET, en general, se utilizan únicamente para leer datos sin realizar modificaciones, mientras que las solicitudes POST y PUT se suelen usar para modificar datos en el servidor. Por ejemplo, la API Stripe le permite usar solicitudes POST para crear un nuevo cargo a fin de que un usuario pueda adquirir algo desde su aplicación.

      Nota: En este artículo se abarcarán solo las solicitudes GET, dado que no modificaremos datos en un servidor.

      Al enviar una solicitud desde una secuencia de comandos de Python o una aplicación web, usted, el desarrollador, puede decidir qué se envía en cada solicitud y qué hacer con la respuesta. Exploremos esto enviando una solicitud a y, luego, usando una API de traducción de idiomas.

      Instalar Requests de Python

      Antes de todo, debemos instalar la biblioteca. Instalaremos, entonces, Requests usando pip. Es recomendable crear un entorno virtual primero si aún no cuenta con uno.

      Nuestra primera solicitud

      Para comenzar, usaremos Requests para enviar una solicitud al sitio Cree un archivo denominado y añádale el código siguiente. En este artículo, la cantidad de código con el que trabajaremos será reducida; por lo tanto, cuando se realice algún cambio podrá actualizar el código existente en lugar de añadir nuevas líneas.

      import requests
      res = requests.get('')

      Lo único que hace este código es enviar una solicitud GET a Este es el mismo tipo de solicitud que envió su navegador para ver esta página, pero la única diferencia es que Requests no puede representar el HTML. Por lo tanto, en su lugar solo obtendrá el HTML sin procesar y el resto de la información de la respuesta.

      En este caso, usaremos la función .get(). Sin embargo, Requests también le permite usar otras funciones, como .post() y .put(), para enviar estas solicitudes.

      Puede ejecutarla con el archivo

      Recibirá esta respuesta: script run with output of `Response 200`

      Códigos de estado

      Lo primero que podemos hacer es verificar el código de estado. Los códigos HTTP van de “1XX” a “5XX”. Los códigos de estado frecuentes que probablemente haya visto son “200”, “404” y “500”.

      A continuación, le ofrecemos una descripción general rápida del significado de cada código de estado:

      • 1XX: información
      • 2XX: éxito
      • 3XX: redireccionamiento
      • 4XX: error del cliente (usted cometió un error)
      • 5XX: error del servidor (se cometió un error en este)

      En general, al realizar sus propias solicitudes lo que busca son códigos de estado del orden del 200.

      Requests reconoce que los códigos de estado 4XX y 5XX son errores. Por lo tanto, si se muestran estos códigos de estado, el objeto de respuesta de la solicitud se evalúa como False.

      Puede probar si se respondió correctamente una solicitud verificando si la respuesta es verdadera. Por ejemplo:

      if res:
          print('Response OK')
          print('Response Failed')

      Resultado “Response 200” seguido de “Response OK”

      El mensaje “Response Failed” solo aparecerá si se muestra un código de estado 400 o 500. Pruebe cambiar la URL por cualquier texto no tenga sentido para ver la falla de la respuesta y la aparición del estado 404.

      Puede ver el código de estado directamente añadiendo lo siguiente:


      Con esto, verá el código de estado directamente para poder verificar el número.

      Resultado de error con 404


      Otro elemento que puede obtener de la respuesta son los encabezados. Puede consultarlos usando el diccionario de encabezados del objeto de respuesta.


      Resultado con encabezados impresos en salida estándar

      Los encabezados se envían junto con la solicitud y se muestran en la respuesta. Los encabezados se utilizan para que tanto el cliente como el servidor puedan interpretar los datos que se envían y se reciben en el envío o la respuesta.

      Vemos los diversos encabezados que se muestran. En muchas ocasiones, no necesitará usar la información de encabezados directamente, pero se encuentra allí si la necesita.

      El tipo de contenido suele ser el que necesita, dado que muestra el formato de los datos; por ejemplo, HTML, JSON, PDF y texto, entre otros. Sin embargo, Requests suele gestionar el tipo de contenido para que pueda acceder a los datos que se muestran.

      Texto de respuesta

      Por último, si examinamos res.text (que funciona para datos textuales, como la página HTML que visualizamos) podemos ver todo el HTML necesario para crear la página de inicio de Scotch. No se representará, pero podemos ver que parece pertenecer a Scotch. Si guardara esto en un archivo y lo abriera, vería algo similar al sitio de Scotch. En una situación real, se deben realizar varias solicitudes para que una página web cargue cosas como imágenes, secuencias de comandos y hojas de estilo. Por lo tanto, si guarda únicamente el HTML en un archivo, no se parecerá en absoluto a la página que ve en su navegador, dado que se realizó una sola solicitud para obtener datos HTML.


      Datos HTML impresos en la línea de comandos

      Usar la API de traducción

      Ahora, pasemos a algo más interesante. Usaremos la API de traducción de Yandex para realizar una solicitud de traducción de texto a otro idioma.

      Para usar la API, primero, debe registrarse. Una vez que se haya registrado, diríjase a la API de traducción y cree una clave de API. Cuando tenga la clave de API, agréguela a su archivo como una constante. Este es el enlace en el que podrá encontrar todo lo mencionado:

      API_KEY = 'your yandex api key'

      Necesitamos una clave de API para que Yandex pueda autenticarnos cada vez que queramos usar su API. La clave de API es una forma de autenticación ligera, dado que se añade al final de la URL de la solicitud al enviarla.

      Para saber qué URL debemos enviar para usar la API, podemos consultar la documentación de Yandex.

      Allí, veremos toda la información necesaria para aplicar su API de traducción en la traducción de texto.

      Sintaxis de la solicitud para usar la API

      Cuando vemos una URL con “&”, “?” y “=”, podemos estar seguros de que la URL se utiliza para solicitudes GET. Estos símbolos especifican los parámetros que se incluyen con la URL.

      En general, todo lo que se encuentre entre corchetes ([]) será opcional. En este caso, el formato, las opciones y la devolución de llamada son opcionales, mientras que la clave, el texto y el idioma son obligatorios para la solicitud.

      Añadiremos código para enviar a esa URL. Puede sustituir la primera solicitud que creamos por esta:

      url = ''
      res = requests.get(url)

      Hay dos formas de añadir parámetros. Podemos añadirlos directamente al final de la URL o hacer que Requests lo haga por nosotros. Para hacer esto último, podemos crear un diccionario para nuestros parámetros. Los tres elementos que necesitamos son la clave, el texto y el idioma. Crearemos el diccionario usando la clave de API 'Hello' para el texto y 'en-es' como idioma, que significa que queremos traducir contenido del inglés al español.

      Si necesita otros códigos de idiomas, puede consultarlos aquí. Busque la columna 639-1.

      Creamos un diccionario de parámetros usando la función dict() y proporcionando las claves y los valores que queremos en nuestro diccionario.

      params = dict(key=API_KEY, text='Hello', lang='en-es')

      Ahora, pasaremos el diccionario de parámetros a la función .get().

      res = requests.get(url, params=params)

      Cuando pasemos los parámetros de esta forma, Requests procederá a añadir los parámetros a la URL por nosotros.

      Ahora, añadiremos una instrucción de impresión para el texto de respuesta y veremos lo que se muestre en la respuesta.


      Diccionario de salida con los valores ingresados

      Se ven tres elementos: El código de estado, que es exactamente el mismo de la respuesta, el idioma que especificamos y el texto traducido dentro de la lista. Por lo tanto, debe ver 'Hola' en el texto traducido.

      Vuelva a probar con el código de idiomas en-fr. Ahora, debería ver 'Bonjour' en la respuesta.

      params = dict(key=API_KEY, text='Hello', lang='en-fr')

      Texto traducido al francés

      Veamos los encabezados de esta respuesta en particular.


      Encabezados impresos en el resultado

      Obviamente, los encabezados serán distintos porque nos comunicamos con un servidor diferente, pero en este caso el tipo de contenido es application/json en lugar de text/html. Esto significa que los datos se pueden interpretar como JSON.

      Cuando application/json es el tipo de contenido de la respuesta, podemos hacer que Requests convierta la respuesta en un diccionario y una lista para que podamos acceder a los datos con mayor facilidad.

      Para que los datos se analicen como JSON, usaremos el método .json() en el objeto de respuesta.

      Si lo imprime, verá que los datos tienen el mismo aspecto, pero el formato es ligeramente diferente.

      json = res.json()

      Es distinto porque ya no es texto simple que usted obtiene de res.text. En este caso, es una versión impresa de un diccionario.

      Supongamos que queremos acceder al texto. Puesto que ahora se trata de un diccionario, podemos usar la clave de texto.


      Ahora solo vemos los datos de esa clave. En este caso, vemos una lista de un elemento; por lo tanto, si quisiéramos obtener ese texto en la lista directamente podríamos acceder a él mediante el índice.


      “Bonjour” sin corchetes

      Ahora, lo único que vemos es la palabra traducida.

      Por supuesto, si modificamos nuestros parámetros obtendremos resultados distintos. Cambiaremos el texto que se traducirá de Hello a Goodbye, volveremos a fijar el español como idioma de destino y reenviaremos la solicitud.

      params = dict(key=API_KEY, text='Goodbye', lang='en-es')

      “Adiós” impreso en el resultado Pruebe traducir textos más largos en distintos idiomas para ver qué respuestas recibe de la API.

      Casos de error en la API de traducción

      Por último, veremos un caso de error. No siempre funciona todo bien. Por lo tanto, necesitamos saber cuándo ocurre un error.

      Pruebe cambiar su clave de API eliminando un carácter. Cuando lo haga, su clave de API dejará de ser válida. Luego, intente enviar una solicitud.

      Al observar el código de estado, esto es lo que verá:


      Error 403 Por lo tanto, cuando utilice la API será conveniente que verifique si todo está en orden o no para poder manejar los casos de error de acuerdo con las necesidades de su aplicación.


      A continuación, se muestra lo que aprendió:

      • Cómo funcionan las solicitudes HTTP
      • Diversos códigos de estado posibles de una respuesta
      • Cómo enviar solicitudes y recibir respuestas usando la biblioteca Requests de Python
      • Cómo usar una API de traducción de idiomas para traducir texto
      • Cómo convertir respuestas de contenido application/JSON en diccionarios

      Si desea ampliar sus posibilidades, consulte esta lista para ver los diferentes tipos de API disponibles e intente usarlos con Requests de Python.

      Source link

      Como começar a usar a biblioteca Requests em Python


      Em vários aplicativos Web, é comum conectar-se a vários serviços de terceiros usando APIs. Ao usar essas APIs, você tem acesso a dados como informações meteorológicas, placares esportivos, listas de filmes, tweets, resultados de mecanismo de busca e fotos. Também é possível usar as APIs para adicionar funcionalidades ao seu app. Exemplos dessas funcionalidades são pagamentos, agendamentos, e-mails, traduções, mapas e transferência de arquivos. Se você tivesse que criar qualquer uma dessas funcionalidades por contra própria, levaria muito tempo, mas com as APIs pode levar somente alguns minutos para se conectar a uma funcionalidade e acessar seus recursos e dados.

      Neste artigo, aprenderemos sobre a biblioteca Requests (Solicitações) do Python, que permite que você envie solicitações HTTP em Python.

      Uma vez que o uso de uma API implica em enviar solicitações HTTP e receber respostas, a biblioteca Requests permite que você utilize APIs no Python. Vamos demonstrar o uso de uma API de tradução de idioma aqui para você veja um um exemplo de como ela funciona.

      Visão geral rápida de solicitações HTTP

      As solicitações HTTP consistem na maneira como a Web funciona. Toda vez que você navega para uma página Web, seu navegador realiza várias solicitações para o servidor da página da Web. Então, o servidor responde com todos os dados necessários para renderizar a página e, na sequência, o seu navegador renderiza a página para que a veja.

      O processo genérico é o que segue: um cliente (como um navegador ou um script Python usando as Requests) enviará alguns dados para um URL e, em seguida, o servidor localizado no URL irá ler os dados, decidir o que fazer com os dados e retornar uma resposta para o cliente. Por fim, o cliente pode decidir o que fazer com os dados na resposta.

      Parte dos dados que o cliente envia em uma solicitação representa o método da solicitação. Alguns métodos de solicitação comuns são o GET, POST e o PUT. Normalmente, as solicitações GET são somente para leitura de dados, sem alterar nada, ao passo que as solicitações POST e PUT são geralmente usadas para modificar os dados no servidor. Por exemplo, a API Stripe permite que você utilize as solicitações POST para criar uma nova cobrança para que um usuário possa comprar algo do seu app.

      Nota: este artigo irá abranger as solicitações GET, pois não vamos modificar nenhum dado em um servidor.

      Ao enviar uma solicitação de um script Python ou uma solicitação dentro de um app Web, caberá a você – o desenvolvedor – decidir o que será enviado em cada solicitação e o que será feito com a respectiva resposta. Assim, vamos explorar isso enviando primeiro uma solicitação para o e, depois, usando uma API de tradução de idiomas.

      Instalar a Requests do Python

      Antes de fazermos qualquer coisa, precisamos instalar a biblioteca. Assim, vamos prosseguir com a instalação da requests, usando o pip. Se você ainda não tiver um ambiente virtual, é uma boa ideia criar um primeiro.

      Nossa primeira solicitação

      Para começar, vamos usar a Requests para solicitar o site Crie um arquivo chamado e adicione o seguinte código a ele. Neste artigo, não teremos muito código para trabalhar, de modo que, quando algo mudar, você somente poderá atualizar o código existente, em vez de adicionar novas linhas.

      import requests
      res = requests.get('')

      Dessa forma, tudo o que esse código está fazendo é enviar uma solicitação GET para o Esse é o mesmo tipo de solicitação que o seu navegador enviou para visualizar essa página. A única diferença, porém, é que a biblioteca Requests, na verdade, não consegue processar páginas em HTML. Assim, em vez de processar a página, você receberá apenas o HTML bruto e outras informações de resposta.

      Estamos usando a função .get() aqui, mas a Requests permite que você utilize outras funções, como .post() e .put() para também enviar essas solicitações.

      Você pode executá-la executando o arquivo

      Aqui está o que você recebe como resultado: script executado com a saída da` Resposta 200`

      Códigos de Status

      A primeira coisa que podemos fazer é verificar o código de status. Os códigos HTTP variam de 1XX a 5XX. Os códigos de status comuns que você provavelmente viu são 200, 404 e 500.

      Aqui está uma visão geral rápida do que cada código de status significa:

      • 1XX – Informação
      • 2XX – Sucesso
      • 3XX – Redirecionar
      • 4XX – Erro de cliente (você cometeu um erro)
      • 5XX – Erro de servidor (eles cometeram um erro)

      Geralmente, o que você está procurando ao realizar suas próprias solicitações são os códigos de status próximos do código 200.

      A Requests reconhece que os códigos de status 4XX e 5XX são erros. Assim, se esses códigos de status forem retornados, significa que o objeto de resposta da solicitação retorna False.

      Você pode testar se uma solicitação respondeu com sucesso, verificando se a resposta é verdadeira. Por exemplo:

      if res:
          print('Response OK')
          print('Response Failed')

      O resultado da Resposta 200 com um acompanhamento de Resposta OK

      A mensagem “Houve falha na resposta” aparecerá apenas se um código de status de 400 ou 500 for retornado. Tente alterar o URL para algo sem sentido para ver a resposta falhar com um código 404.

      Você pode verificar o código de status diretamente, adicionando:


      Isso mostrará o código de status diretamente para que você mesmo possa verificar o número.

      Saída de falha com código 404


      Outra coisa que você pode receber da resposta são os cabeçalhos. Você pode verificá-los usando o dicionário de cabeçalhos no objeto de resposta.


      saída com cabeçalhos impressos em saída padrão

      Os cabeçalhos são enviados com a solicitação e retornados na resposta. Os cabeçalhos são usados para que o cliente e o servidor saibam como interpretar os dados que estão sendo enviados e recebidos na solicitação/resposta

      Nós conseguimos ver os diversos cabeçalhos que são retornados. Muitas vezes você não precisará usar as informações do cabeçalho diretamente, mas elas ficarão disponíveis, caso precise delas.

      Normalmente, o tipo de conteúdo é aquele que você pode precisar, pois ele revela o formato dos dados, por exemplo, HTML, JSON, PDF, texto, etc. O tipo de conteúdo, porém, é normalmente tratado pelas Requests para que você possa acessar os dados que são retornados.

      Texto de resposta

      E, por fim, se examinarmos o res.text (isto funciona para os dados de texto, como a página HTML que estamos visualizando), podemos ver tudo o que o HTML precisou para compilar a página inicial do Scotch. A página não será processada, mas podemos ver que, aparentemente, ela pertence ao Scotch. Se você salvou isso em um arquivo e o abriu, você veria algo que lembraria o site do Scotch. Em uma situação real, várias solicitações são feitas para que uma única página Web carregue coisas como imagens, scripts e folha de estilos, etc. Assim, se você salvar somente o HTML em um arquivo, a página não ficará parecida com a página do que você vê em seu navegador, pois só foi realizada uma solicitação para obter os dados de HTML.


      Dados de HTML impressos na linha de comando

      Usando a API de tradução

      Agora, vamos prosseguir para algo mais interessante. Utilizaremos a API Yandex Translate para realizar uma solicitação para traduzir algum texto para um idioma diferente.

      Para usar a API, primeiro é necessário inscrever-se. Depois de se inscrever, vá para a API Translate e crie uma chave de API. Assim que tiver a chave da API, adicione-a ao seu arquivo como uma constante. Aqui está o link onde você pode fazer todas essas coisas:

      API_KEY = 'your yandex api key'

      Precisamos de uma chave API para que o Yandex possa nos autenticar sempre que quisermos usar a API deles. A chave da API é uma forma leve de autenticação, pois ela é adicionada ao final da URL da solicitação, quando for enviada.

      Para saber qual URL precisamos enviar para usar a API, podemos examinar a documentação do Yandex.

      Se procurarmos lá, veremos todas as informações necessárias para usarmos a API Translate deles informação necessária para usar a API Translate deles para traduzir textos.

      Sintaxe da solicitação para usar a API

      Quando vemos um URL com “e” comercial (&), pontos de interrogação (? ) e sinais de igual (=), é certo que o URL é feito para pedidos de GET. Esses símbolos especificam os parâmetros que acompanham o URL.

      Normalmente, as coisas entre chaves ([]) serão opcionais. Neste caso, formato, opções e retorno de chamada são opcionais, enquanto chave, texto e idioma são necessários para a solicitação.

      Vamos adicionar um código para enviar para aquele URL. Você pode substituir a primeira solicitação que criamos por esta:

      url = ''
      res = requests.get(url)

      Existem duas maneiras de adicionar os parâmetros. Podemos anexá-los diretamente ao final do URL, ou podemos fazer com que as Requests façam isso por nós. Para fazer essa última, podemos criar um dicionário para nossos parâmetros. Os três itens que precisamos são a chave, o texto e o idioma. Vamos criar o dicionário usando a chave da API, 'Hello' para o texto e 'en-es' como o idioma, o que significa que queremos traduzir do inglês para o espanhol.

      Se precisar saber qualquer outro código de idioma, procure aqui. Você está procurando pela coluna 639-1.

      Criamos um dicionário de parâmetros usando a função dict() e enviando as chaves e os valores que queremos em nosso dicionário.

      params = dict(key=API_KEY, text='Hello', lang='en-es')

      Agora, tomamos o dicionário de parâmetros e o enviamos para a função .get().

      res = requests.get(url, params=params)

      Ao enviarmos os parâmetros desta maneira, as Requests prosseguirão e adicionarão os parâmetros ao URL para nós.

      Agora, vamos adicionar uma instrução de impressão relacionada ao texto da resposta e visualizaremos o que será retornado na resposta.


      dicionário de saída com os valores inseridos

      Vemos três coisas. Vemos o código de status, que é exatamente o mesmo código de status da resposta, propriamente dita; vemos o idioma que especificamos e o texto traduzido dentro da lista. Então você deverá ver 'Hola' como o texto traduzido.

      Tente novamente com en-fr como o código de idioma e você deverá ver 'Bonjour' na resposta agora.

      params = dict(key=API_KEY, text='Hello', lang='en-fr')

      Texto traduzido em francês

      Vamos examinar os cabeçalhos dessa resposta em particular.


      Cabeçalhos impressos na saída

      Obviamente, os cabeçalhos devem ser diferentes, pois estamos nos comunicando com um servidor diferente; neste caso, porém, o tipo de conteúdo é o application/json, em vez de text/html. Isso significa que os dados podem ser interpretados como JSON.

      Quando o application/json for o tipo de conteúdo da resposta, conseguimos fazer com que as Requests convertam a resposta em um dicionário e uma lista, de modo que possamos acessar os dados mais facilmente.

      Para ter os dados analisados como JSON, usamos o método .json() no objeto de resposta.

      Se você o imprimir, verá que os dados parecem iguais, mas o formato é ligeiramente diferente.

      json = res.json()

      O motivo dessa diferença está no fato de que ele n qual ele é diferente é porque ele já não é um texto simples que você obteve do res.text. Desta vez, é uma versão impressa de um dicionário.

      Vamos supor que queiramos acessar o texto. Considerando que agora se trata de um dicionário, poderemos usar a sshave de texto


      Agora, vemos apenas os dados dessa chave específica. Neste caso, estamos examinando uma lista de um item; assim, se quisermos pegar esse texto diretamente na lista, poderemos acessá-lo pelo índice.


      "Bonjour" sem os colchetes

      Agora, a única coisa que vemos é a palavra traduzida.

      É claro que, se alterarmos as coisas em nossos parâmetros, vamos receber resultados diferentes. Vamos alterar o texto que será traduzido de Hello para Goodbye, alterar o idioma de chegada de volta para espanhol e enviar a solicitação novamente.

      params = dict(key=API_KEY, text='Goodbye', lang='en-es')

      "Adios" impresso na saída Tente traduzir um texto maior em diferentes idiomas e veja quais respostas a API dará a você.

      Casos de erro da API de tradução

      Por fim, vamos examinar um caso de erro. Nem sempre tudo funciona. Assim, precisamos saber reconhecer quando isso acontece.

      Tente alterar sua chave de API, removendo um caractere. Quando fizer isso, sua chave de API não será mais válida. Então, tente enviar uma solicitação.

      Se você examinar o código de status, eis o que você receberá:


      Erro 403 Portanto, quando estiver usando a API, você vai querer verificar se as coisas foram bem-sucedidas ou não, para que você possa lidar com os casos de erro de acordo com as necessidades do seu app.


      Veja o que aprendemos hoje:

      • Como as solicitações HTTP funcionam
      • Os vários códigos de status possíveis em uma resposta
      • Como enviar solicitações e receber respostas usando a biblioteca Requests do Python
      • Como usar uma API de tradução de idioma para traduzir textos
      • Como converter respostas de conteúdo application/JSON em dicionários

      Se quiser fazer mais, confira esta lista para ver as diferentes APIs disponíveis e tente usá-las com a Requests do Python.

      Source link