Python

Pandas Sort：Python 数据排序指南

在本 Python 教程中，我们将了解 Pandas Sort：Python 数据排序指南。了解如何使用 .sort_values() 函数对 pandas Dataframe 中的数据行进行排序。

如果更改行的顺序，通常会更容易在 DataFrame 中查找有趣的数据位。您可以通过将列名传递给 来对行进行排序.sort_values()。

在行具有相同值的情况下（如果您对分类变量进行排序，这很常见），您可能希望通过对另一列进行排序来打破这种联系。您可以通过传递列名列表以这种方式对多列进行排序。

修改列的顺序

您可以通过对行进行排序来更改行的顺序，以便最有趣的数据位于数据框的顶部。

例如，当我们在 dogs 数据框的列sort_values()上应用weight_kg时，我们得到顶部最轻的狗 Stella the Chihuahua，以及底部最重的狗 Bernie the Saint Bernard。

dogs.sort_values("weight_kg")

      name        breed  color  height_cm  weight_kg date_of_birth
5   Stella    Chihuahua    Tan         18          2    2015-04-20
3   Cooper    Schnauzer   Gray         49         17    2011-12-11
0    Bella     Labrador  Brown         56         24    2013-07-01
1  Charlie       Poodle  Black         43         24    2016-09-16
2     Lucy    Chow Chow  Brown         46         24    2014-08-25
4      Max     Labrador  Black         59         29    2017-01-20
6   Bernie  St. Bernard  White         77         74    2018-02-27

将参数设置ascending为 False 将以相反的方式对数据进行排序，从最重的狗到最轻的狗。

dogs.sort_values("weight_kg", ascending=False)

      name        breed  color  height_cm  weight_kg date_of_birth
6   Bernie  St. Bernard  White         77         74    2018-02-27
4      Max     Labrador  Black         59         29    2017-01-20
0    Bella     Labrador  Brown         56         24    2013-07-01
1  Charlie       Poodle  Black         43         24    2016-09-16
2     Lucy    Chow Chow  Brown         46         24    2014-08-25
3   Cooper    Schnauzer   Gray         49         17    2011-12-11
5   Stella    Chihuahua    Tan         18          2    2015-04-20

按多个变量排序

我们可以通过将列名列表传递给 来按多个变量排序sort_values。在这里，我们先按重量排序，然后按身高排序。现在，查理、露西和贝拉按从矮到高的顺序排列，尽管他们的体重都一样。

dogs.sort_values(["weight_kg", "height_cm"])

      name        breed  color  height_cm  weight_kg date_of_birth
5   Stella    Chihuahua    Tan         18          2    2015-04-20
3   Cooper    Schnauzer   Gray         49         17    2011-12-11
1  Charlie       Poodle  Black         43         24    2016-09-16
2     Lucy    Chow Chow  Brown         46         24    2014-08-25
0    Bella     Labrador  Brown         56         24    2013-07-01
4      Max     Labrador  Black         59         29    2017-01-20
6   Bernie  St. Bernard  White         77         74    2018-02-27

要更改值的排序方向，请将列表传递给升序参数以指定应为每个变量执行哪个方向排序。现在，查理、露西和贝拉按从高到矮的顺序排列。

dogs.sort_values(["weight_kg", "height_cm"], ascending=[True, False])

      name        breed  color  height_cm  weight_kg date_of_birth
5   Stella    Chihuahua    Tan         18          2    2015-04-20
3   Cooper    Schnauzer   Gray         49         17    2011-12-11
0    Bella     Labrador  Brown         56         24    2013-07-01
2     Lucy    Chow Chow  Brown         46         24    2014-08-25
1  Charlie       Poodle  Black         43         24    2016-09-16
4      Max     Labrador  Black         59         29    2017-01-20
6   Bernie  St. Bernard  White         77         74    2018-02-27

互动范例

在以下示例中，您将按homelessness无家可归者人数从小到大排序，并将其另存为homelessness_ind. 最后，您将打印排序后的 DataFrame 的头部。

# Sort homelessness by individuals
homelessness_ind = homelessness.sort_values("individuals")

# Print the top few rows
print(homelessness_ind.head())

当我们运行上面的代码时，它会产生以下结果：

                region         state  individuals  family_members  state_pop
50            Mountain       Wyoming        434.0           205.0     577601
34  West North Central  North Dakota        467.0            75.0     758080
7       South Atlantic      Delaware        708.0           374.0     965479
39         New England  Rhode Island        747.0           354.0    1058287
45         New England       Vermont        780.0           511.0     624358

自己试试吧。

要了解有关对数据进行排序和子集化的更多信息，请观看我们课程Data Manipulation with pandas中的视频。

此内容摘自 Maggie Matsui 和 Richie Cotton 编写的 DataCamp 的Data Manipulation with pandas课程。

文章来源： https: //www.datacamp.com

#python #pandas 

How to Handling HTTP Requests in Python

In this tutorial, We will explore the requests library in Python to handle multiple HTTP requests. We will take a look at making requests using different methods, methods in response objects, and exceptions.

Prerequisites

• Basic understanding of HTTP(S) request methods (GET, POST, PUT, DELETE)
• Install and possess knowledge of any Python IDE
• Installed pip to download requests library
• Basic python syntax

Install Requests Library

To install the requests library that we’ll be referring to in this tutorial, open the terminal and go to your desired installation directory and copy and paste the following command:

python -m pip install requests

To check if the library has been installed correctly, type the following command:

python -m pip show requests

The output should contain the name and the version of the library installed. If it shows a warning that says Package(s) not found, then restart the terminal and type the command above again. If it still does not show the package, try reinstalling.

HTTP Requests in Python

Requests can simply be thought of as an elegant and simple HTTP library for Python, built to ease sending and receiving  HTTP requests using Python.

And the most basic request is:

 r = requests.get('https://codesource.io/')

This will return a Response object which is stored in the variable r.

This response object has several methods which you can use to see the data you received from the get request.

To add Parameters to your GET request,

r = requests.get('https://httpbin.org/get', params={'q': 'value', 'key': 'value'})

Or, more conventionally put the parameters in a variable

payload = {'q': 'value', 'key': 'value'}
 r = requests.get('https://httpbin.org/get', params=payload)

You can also pass a list of items as value,

payload = {'key1': 'value1', 'key2': ['value2', 'value3']}
    r = requests.get('https://httpbin.org/get', params=payload)
    print(r.url)
    #Output:- https://httpbin.org/get?key1=value1&key2=value2&key2=value3

To see other request methods, try using the following commands:

POST

  r = requests.post('https://httpbin.org/post', data={'key': 'value'})

PUT

 r = requests.put('https://httpbin.org/put', data={'key': 'value'})

DELETE

  r = requests.delete('https://httpbin.org/delete')

Methods for Response Objects

First, let’s make a GET request,

r = requests.get('https://codesource.io/')

Some basic and important methods for Response objects,

status_code

A very important method to check if your request was a success.

print(r.status_code)
    #Output:- 200

You can also use a simple if condition to check if the request was a success.

if r.status_code:
      #Do something

The if condition will evaluate to true if the response code begins with 2 meaning a response code of 2xx for OK or 3 meaning 3xx for redirects.

URL

To get the URL used in your get request,

   print(r.url)
    #Output:- https://codesource.io/

text

To get the text from a get request Response object,

   print(r.text)

binary content

To get the content of your request in binary,

print(r.content)

JSON

In a case where you want to convert your received response to JSON, you can use the library’s inbuilt function to convert your response object to JSON.

print(r.json())

Custom Response Headers

For custom headers, simply pass a dictionary to the headers parameter in the request.

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

The above code example sets a custom user-agent in the header for the request.

Exceptions

If you enter an incorrect URL in your request, it will raise a requests.exceptions.ConnectionError  or if you don’t put a http:// or https:// in front of your URL, it will raise a requests.exceptions.MissingSchema.

All exceptions that Requests explicitly raises inherit from requests.exceptions.RequestException.

Complicated POST Requests

Typically, you want to send some form-encoded data — much like an HTML form. To do so, just pass a dictionary to the data argument in our request.

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

You can also pass multiple values to the same key in the form of a list or a tuple.

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

Redirection and History

By default, Requests will perform location redirection for all verbs(GET, POST, PUT, DELETE, OPTIONS, PATCH) except HEAD.

We can use the history property of the Response object to track redirection.

By default, GitHub redirects HTTP links to HTTPS.

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

You can disable redirections by setting the allow_redirects argument to False

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

Summary

• Requests is an elegant and simple HTTP library for Python, built for human beings.
• A request returns a Response object.
• To add parameters to a request set the params argument value to a dictionary containing key-value pairs.
• For POST and PUT requests, assign data to the data argument in the request.
• Response objects have several properties to get information about the response.
• By default, every verb except HEAD has allow_redirects set to true.

Original article source at: https://codesource.io/

#python #handling #http 

Pandas DataFrame apply() Các ví dụ trong Python

Trong hướng dẫn Pandas này, chúng ta sẽ tìm hiểu về các ví dụ áp dụng khung dữ liệu Pandas (). Một cách khác để sử dụng vòng lặp để lặp qua DataFrame là sử dụng .apply()phương pháp gấu trúc. Hàm này hoạt động như một map()hàm trong Python. Nó lấy một chức năng làm đầu vào và áp dụng chức năng này cho toàn bộ Khung dữ liệu.

Nếu bạn đang làm việc với dữ liệu dạng bảng, bạn phải chỉ định một trục mà bạn muốn hàm của mình hoạt động trên đó ( 0cho cột; và 1cho hàng).

Giống như map()hàm, apply()phương thức này cũng có thể được sử dụng với hàm ẩn danh hoặc hàm lambda. Hãy xem xét một số apply()ví dụ sử dụng dữ liệu bóng chày.

Tính chênh lệch chạy với.apply()

Đầu tiên, bạn sẽ gọi .apply()phương thức trên basebal_dfkhung dữ liệu. Sau đó sử dụng lambdachức năng để lặp qua các hàng của khung dữ liệu. Đối với mỗi hàng, chúng tôi lấy các cột RSvà RAvà chuyển chúng cho calc_run_diffhàm. Cuối cùng, bạn sẽ chỉ định phương thức axis=1cho biết .apply()mà chúng ta muốn áp dụng nó trên các hàng thay vì các cột.

baseball_df.apply(
    lambda row: calc_run_diff(row['RS'], row['RA']),
    axis=1
)

Bạn sẽ nhận thấy rằng chúng ta không cần sử dụng forvòng lặp. Bạn có thể thu thập các chênh lệch chạy trực tiếp vào một đối tượng có tên là run_diffs_apply. Sau khi tạo một cột mới và in khung dữ liệu, bạn sẽ nhận thấy rằng các kết quả tương tự như những gì bạn sẽ nhận được với .iterrows()phương pháp này.

run_diffs_apply = baseball_df.apply(
         lambda row: calc_run_diff(row['RS'], row['RA']),
         axis=1)
baseball_df['RD'] = run_diffs_apply
print(baseball_df)

      Team    League    year   RS    RA    W    G   Playoffs    RD
0      ARI        NL    2012  734   688   81  162          0    46
1      ATL        NL    2012  700   600   94  162          1   100
2      BAL        AL    2012  712   705   93  162          1     7 

Ví dụ tương tác Sử dụng.apply()

Tampa Bay Rays muốn bạn phân tích dữ liệu của họ.

Họ muốn các số liệu sau:

• Tổng của mỗi cột trong dữ liệu
• Tổng số lần chạy ghi được trong một năm ( 'RS'+ 'RA'cho mỗi năm)
• Cột 'Playoffs'ở định dạng văn bản thay vì sử dụng 1'svà0's

Hàm dưới đây có thể được sử dụng để chuyển đổi 'Playoffs'cột thành văn bản:

def text_playoffs(num_playoffs):
    if num_playoffs == 1:
        return 'Yes'
    else:
      return 'No'

Sử dụng .apply()để có được những số liệu này. Một DataFrame ( rays_df) đã được in bên dưới. DataFrame này được lập chỉ mục trên 'Year'cột.

       RS   RA   W  Playoffs
2012  697  577  90         0
2011  707  614  91         1
2010  802  649  96         1
2009  803  754  84         0
2008  774  671  97         1 

• Áp dụng sum()cho mỗi cột của rays_dfđể thu thập tổng của mỗi cột. Hãy chắc chắn để xác định chính xác axis.

# Gather sum of all columns
stat_totals = rays_df.apply(sum, axis=0)
print(stat_totals)

Khi chúng tôi chạy đoạn mã trên, nó tạo ra kết quả như sau:

RS          3783
RA          3265
W            458
Playoffs       3
dtype: int64

Hãy thử nó cho chính mình .

Để tìm hiểu thêm về pandas thay thế cho vòng lặp, vui lòng xem video này từ khóa học Viết mã Python hiệu quả của chúng tôi .

Nội dung này được lấy từ khóa học Python trung cấp của DataCamp bởi Logan Thomas.

Nguồn bài viết: https://www.datacamp.com

#pandas #python 

Aprenda Django construindo uma filtragem colaborativa em Python

Neste tutorial do Django, aprenderemos sobre o Django construindo uma filtragem colaborativa em Python. 

Aprenda Django com este projeto! Crie um mecanismo de recomendação em Django. Crie uma filtragem colaborativa com Python, Celery, Django, Worker Processes, Batch Predictions, SurpriseML, Keras e muito mais! Crie um mecanismo de recomendação usando Django e uma técnica de Machine Learning chamada Filtragem Colaborativa.

Os usuários avaliarão os filmes e o sistema recomendará automaticamente novos. Essas recomendações serão feitas em lotes (ou seja, não em tempo real) para desbloquear um sistema mais escalável para treinar e ajudar milhares e milhares de usuários.

Para este curso, usaremos um conjunto de dados real chamado MovieLens; esse conjunto de dados é baixado em CSV e é usado em todos os tipos de tutoriais de aprendizado de máquina. O que há de especial neste curso é que você carregará este conjunto de dados em um banco de dados SQL por meio de um modelo Django. Isso por si só pode valer a pena assistir ao curso, pois os bancos de dados SQL são muito mais poderosos que os arquivos CSV.

Para fazer a inferência em lote, implementamos o incrivelmente poderoso processo de trabalho em segundo plano chamado Celery. Se você nunca usou o Celery antes, esta será uma experiência reveladora e, ao acoplá-lo ao Django, você terá um processo de trabalho verdadeiramente poderoso que pode executar tarefas em segundo plano, executar tarefas em um cronograma ou uma combinação de ambos. Tarefas no Celery são simplesmente funções do Python com um decorador especial.

Para classificar filmes, usaremos HTMX. HTMX é uma maneira de atualizar o conteúdo dinamicamente sem recarregar a página. Tenho certeza de que você conhece a experiência sempre que clica em "curtir" ou "inscrever-se", é isso que o HTMX nos oferece sem a sobrecarga de usar 1 linha de JavaScript. Este curso nos mostra uma implementação prática do uso do HTMX não apenas para classificar filmes, mas também para classificá-los, carregá-los e fazer muito mais.

O mecanismo de recomendação no Django é realmente uma coleção de 3 partes:

Processo da Web: configure o Django para coletar o interesse do usuário e fornecer recomendações quando disponíveis.
Pipeline de aprendizado de máquina: extraia dados do Django, transforme-os e treine um modelo de filtragem colaborativa.
Processo de trabalho: Esta é a cola. Usaremos o Celery para agendar/executar as previsões do modelo treinado e atualizar dados para recomendações de usuários relacionadas ao Django.

O que você aprenderá:

Aprender

• como integrar Django & Celery
• Aprenda a usar HTMX com Django para carregamento dinâmico (sem necessidade de JavaScript)
• Treinando um modelo de aprendizado de máquina com SurpriseML e um exemplo em Keras
• Construa um sistema de classificação em Django com botões de classificação dinâmicos. Essas classificações podem ser usadas em qualquer modelo Django
• Aprenda a executar tarefas periódicas em segundo plano e/ou funções de agendamento para serem executadas exatamente quando necessário
• Como executar a inferência em lote de maneira eficaz usando o Django para grandes cargas de trabalho e/ou pacotes de ML
• Como carregar grandes conjuntos de dados em um banco de dados SQL por meio de modelos Django
• Onde encontrar ótimos conjuntos de dados online
• Como implementar uma página de revisão "infinita" que sempre dará um novo item após a classificação.
• Muito mais!

Fonte do artigo: https://dev.to

#django  #python 

Проверьте, есть ли у объекта атрибут в Python

Чтобы проверить, имеет ли объект определенный атрибут или нет, вы можете использовать функцию hasattr().

При вызове hasattr()функции нужно передать 2 параметра: объект и имя атрибута в виде строки.

Когда атрибут существует, функция возвращает True. В противном случае возвращается False.

Вот пример проверки наличия у строки атрибута с именем join:

my_str = 'ABC'

print(hasattr(my_str, 'join'))  # True

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

В этом примере проверяется, my_carесть ли у объекта атрибут с именем brandand wheels:

class Car:
    def __init__(self):
        self.brand = 'Tesla'
        self.year = 2002

my_car = Car()

print(hasattr(my_car, 'brand'))  # True
print(hasattr(my_car, 'wheels'))  # False

Как видите, hasattr()вывод функции можно использовать для расширения вашего кода, включая условные операторы, такие как ifоператор.

Я надеюсь, что это руководство поможет. Удачного кодирования!

Оригинальный источник статьи: https://sebhastian.com/

#python #object 

在 Python 中检查对象是否具有属性

要检查对象是否具有某个属性，可以使用该hasattr()函数。

调用该hasattr()函数时，需要传递 2 个参数：对象和作为字符串的属性名称。

当属性存在时，函数返回True。否则，它返回False。

下面是检查字符串是否具有名为 的属性的示例join：

my_str = 'ABC'

print(hasattr(my_str, 'join'))  # True

您还可以检查从类实例化的对象是否具有特定属性。

此示例检查对象是否具有名为and 的my_car属性：brandwheels

class Car:
    def __init__(self):
        self.brand = 'Tesla'
        self.year = 2002

my_car = Car()

print(hasattr(my_car, 'brand'))  # True
print(hasattr(my_car, 'wheels'))  # False

如您所见，hasattr()函数输出可用于通过包含条件语句（例如if语句）来进一步完善您的代码。

我希望本教程有所帮助。编码愉快！

原始文章来源：https: //sebhastian.com/

#python #object 

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

Когда вам нужно получить значения словаря в виде списка, вы можете использовать 4 решения:

1. Использование list()функции и dict.values()метода
2. Распакуйте значения в виде списка, используя *символ звездочки
3. Использование понимания списка
4. Использование forцикла

Я покажу вам, как использовать эти 4 решения на практике.

1. Использование методов list() и dict.values()

Чтобы извлечь значения из словаря, вы можете использовать dict.values()метод. После этого вам нужно только вызвать list()функцию для преобразования вывода в список

Вот пример:

organization = {
    'ceo': 'Nathan',
    'coo': 'Andy',
    'cfo': 'Johnny'
}

my_list = list(organization.values())

print(my_list)

Выход:

['Nathan', 'Andy', 'Johnny']

Как видите, решение успешно извлекло значения из словаря.

2. Распакуйте значения в виде списка, используя *символ звездочки.

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

organization = {
    'ceo': 'Nathan',
    'coo': 'Andy',
    'cfo': 'Johnny'
}

my_list = [*organization.values()]

print(my_list)

Выход:

['Nathan', 'Andy', 'Johnny']

Выражение со звездочкой распаковывает значения из dict_valueитерируемого объекта, и мы использовали список []для хранения распакованных значений.

3. Использование понимания списка

Другой способ извлечь значения из словаря — использовать понимание списка и метод dict.values():

organization = {
    'ceo': 'Nathan',
    'coo': 'Andy',
    'cfo': 'Johnny'
}

my_list = [i for i in organization.values()]

print(my_list)

Выход:

['Nathan', 'Andy', 'Johnny']

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

4. Использование forцикла

Вы также можете использовать forцикл для перебора самого словаря:

organization = {
    'ceo': 'Nathan',
    'coo': 'Andy',
    'cfo': 'Johnny'
}

my_list = []
for i in organization.values():
    my_list.append(i)

print(my_list)

Выход:

['Nathan', 'Andy', 'Johnny']

В этом решении вам нужно создать пустой список перед запуском for цикла.

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

Оригинальный источник статьи: https://sebhastian.com/

#python #dictionary #values 

Como classificar os valores do Pandas

Neste tutorial do Pandas, aprenderemos sobre como classificar os valores do Pandas. Aprenda como classificar linhas de dados em um Pandas Dataframe usando a função .sort_values().

Encontrar bits de dados interessantes em um DataFrame geralmente é mais fácil se você alterar a ordem das linhas. Você pode classificar as linhas passando um nome de coluna para .sort_values().

Nos casos em que as linhas têm o mesmo valor (isso é comum se você classificar em uma variável categórica), convém quebrar os empates classificando em outra coluna. Você pode classificar em várias colunas dessa maneira, passando uma lista de nomes de colunas.

Modificando a Ordem das Colunas

Você pode alterar a ordem das linhas classificando-as para que os dados mais interessantes estejam no topo do dataframe.

Por exemplo, quando aplicamos sort_values()na weight_kgcoluna do dataframe dos cães, obtemos o cachorro mais leve no topo, Stella the Chihuahua, e o cachorro mais pesado na parte inferior, Bernie the Saint Bernard.

dogs.sort_values("weight_kg")

      name        breed  color  height_cm  weight_kg date_of_birth
5   Stella    Chihuahua    Tan         18          2    2015-04-20
3   Cooper    Schnauzer   Gray         49         17    2011-12-11
0    Bella     Labrador  Brown         56         24    2013-07-01
1  Charlie       Poodle  Black         43         24    2016-09-16
2     Lucy    Chow Chow  Brown         46         24    2014-08-25
4      Max     Labrador  Black         59         29    2017-01-20
6   Bernie  St. Bernard  White         77         74    2018-02-27

Definir o ascendingargumento como Falso classificará os dados ao contrário, do cachorro mais pesado para o mais leve.

dogs.sort_values("weight_kg", ascending=False)

      name        breed  color  height_cm  weight_kg date_of_birth
6   Bernie  St. Bernard  White         77         74    2018-02-27
4      Max     Labrador  Black         59         29    2017-01-20
0    Bella     Labrador  Brown         56         24    2013-07-01
1  Charlie       Poodle  Black         43         24    2016-09-16
2     Lucy    Chow Chow  Brown         46         24    2014-08-25
3   Cooper    Schnauzer   Gray         49         17    2011-12-11
5   Stella    Chihuahua    Tan         18          2    2015-04-20

Classificando por Múltiplas Variáveis

Podemos classificar por várias variáveis ​​passando uma lista de nomes de colunas para sort_values. Aqui, classificamos primeiro por peso e depois por altura. Agora, Charlie, Lucy e Bella são ordenados do menor para o maior, embora todos tenham o mesmo peso.

dogs.sort_values(["weight_kg", "height_cm"])

     name        breed  color  height_cm  weight_kg date_of_birth
5   Stella    Chihuahua    Tan         18          2    2015-04-20
3   Cooper    Schnauzer   Gray         49         17    2011-12-11
1  Charlie       Poodle  Black         43         24    2016-09-16
2     Lucy    Chow Chow  Brown         46         24    2014-08-25
0    Bella     Labrador  Brown         56         24    2013-07-01
4      Max     Labrador  Black         59         29    2017-01-20
6   Bernie  St. Bernard  White         77         74    2018-02-27

Para alterar a direção em que os valores são classificados, passe uma lista para o argumento ascendente para especificar qual classificação de direção deve ser feita para cada variável. Agora, Charlie, Lucy e Bella estão ordenados do mais alto para o mais baixo.

dogs.sort_values(["weight_kg", "height_cm"], ascending=[True, False])

      name        breed  color  height_cm  weight_kg date_of_birth
5   Stella    Chihuahua    Tan         18          2    2015-04-20
3   Cooper    Schnauzer   Gray         49         17    2011-12-11
0    Bella     Labrador  Brown         56         24    2013-07-01
2     Lucy    Chow Chow  Brown         46         24    2014-08-25
1  Charlie       Poodle  Black         43         24    2016-09-16
4      Max     Labrador  Black         59         29    2017-01-20
6   Bernie  St. Bernard  White         77         74    2018-02-27

Exemplo interativo

No exemplo a seguir, você classificará homelessnesspelo número de moradores de rua, do menor para o maior, e salvará como homelessness_ind. Por fim, você imprimirá a cabeça do DataFrame classificado.

# Sort homelessness by individuals
homelessness_ind = homelessness.sort_values("individuals")

# Print the top few rows
print(homelessness_ind.head())

Quando executamos o código acima, ele produz o seguinte resultado:

                region         state  individuals  family_members  state_pop
50            Mountain       Wyoming        434.0           205.0     577601
34  West North Central  North Dakota        467.0            75.0     758080
7       South Atlantic      Delaware        708.0           374.0     965479
39         New England  Rhode Island        747.0           354.0    1058287
45         New England       Vermont        780.0           511.0     624358

Experimente você mesmo .

Para saber mais sobre como classificar e subconfigurar os dados, veja este vídeo do nosso curso Data Manipulation with pandas .

Este conteúdo foi retirado do curso DataCamp's Data Manipulation with pandas de Maggie Matsui e Richie Cotton.

Fonte do artigo: https://www.datacamp.com

#pandas  #python 

Check If an Object Has An Attribute in Python

To check if an object has a certain attribute or not, you can use the hasattr() function.

When calling the hasattr() function, you need to pass 2 parameters: the object and the attribute name as a string.

When the attribute exists, the function returns True. Otherwise, it returns False.

Here’s an example of checking if a string has an attribute called join:

my_str = 'ABC'

print(hasattr(my_str, 'join'))  # True

You can also check if an object instantiated from a class has a certain attribute.

This example checks if the my_car object has an attribute called brand and wheels:

class Car:
    def __init__(self):
        self.brand = 'Tesla'
        self.year = 2002

my_car = Car()

print(hasattr(my_car, 'brand'))  # True
print(hasattr(my_car, 'wheels'))  # False

As you can see, the hasattr() function output can be used to further your code by including conditionals such as an if statement.

I hope this tutorial helps. Happy coding!

Original article source at: https://sebhastian.com/

#python #object 

在 Python 中将字典值作为列表获取

当您需要将字典的值作为列表获取时，您可以使用 4 种解决方案：

1. 使用list()函数和dict.values()方法
2. *使用星号将值解压缩为列表
3. 使用列表理解
4. 使用for循环

我将向您展示如何在实践中使用这 4 种解决方案

1. 使用 list() 和 dict.values() 方法

要从字典中提取值，您可以使用该dict.values()方法。之后，你只需要调用list()函数将输出转换为列表

这是一个例子：

organization = {
    'ceo': 'Nathan',
    'coo': 'Andy',
    'cfo': 'Johnny'
}

my_list = list(organization.values())

print(my_list)

输出：

['Nathan', 'Andy', 'Johnny']

如您所见，该解决方案成功地从字典中提取了值。

*2. 使用星号将值解压缩为列表

或者，您也可以使用星*号将值解压缩为列表，如下所示：

organization = {
    'ceo': 'Nathan',
    'coo': 'Andy',
    'cfo': 'Johnny'
}

my_list = [*organization.values()]

print(my_list)

输出：

['Nathan', 'Andy', 'Johnny']

带星号的表达式从可迭代对象中解压值dict_value，我们使用一个列表[]来存储解压后的值。

3.使用列表理解

从字典中提取值的另一种方法是使用列表理解和方法dict.values()：

organization = {
    'ceo': 'Nathan',
    'coo': 'Andy',
    'cfo': 'Johnny'
}

my_list = [i for i in organization.values()]

print(my_list)

输出：

['Nathan', 'Andy', 'Johnny']

与星号表达式类似，列表理解使用循环for将对象中的每个项目提取dict_values到列表中。

4.使用for循环

您还可以使用for循环来遍历字典本身：

organization = {
    'ceo': 'Nathan',
    'coo': 'Andy',
    'cfo': 'Johnny'
}

my_list = []
for i in organization.values():
    my_list.append(i)

print(my_list)

输出：

['Nathan', 'Andy', 'Johnny']

在此解决方案中，您需要在运行循环之前创建一个空列表for 。

这就是在 Python 中将字典值作为列表获取的方式。您可能还想查看我关于获取 Python 字典中的第一个键的其他教程。

原始文章来源：https: //sebhastian.com/

#python #dictionary #values 

Learn Django by Building a Collaborative Filtering in Python

In this Django tutorial, we will learn about Django by Building a Collaborative Filtering in Python. 

Learn Django with this one project! Build a Recommendation Engine in Django. Build a collaborative filtering with Python, Celery, Django, Worker Processes, Batch Predictions, SurpriseML, Keras, and more! Build a recommendation engine using Django & a Machine Learning technique called Collaborative Filtering.

Users will rate movies and the system will automatically recommend new ones. These recommendations will be done in batches (ie not in real time) to unlock a more scalable system for training and helping thousands and thousands of users.

For this course, we'll use a real dataset called MovieLens; this dataset is downloaded in CSV and is used on all kinds of machine learning tutorials. What's special about this course is you'll load this dataset into a SQL database through a Django model. This alone might be worth watching the course as SQL databases are far more powerful than CSV files.

To do the batch inference we implement the incredibly powerful background worker process called Celery. If you haven't used Celery before, this will be an eye opening experience and when you couple it with Django you have a truly powerful worker process that can run tasks in the background, run tasks on a schedule, or a combination of both. Tasks in Celery are simply Python functions with a special decorator.

For rating movies, we'll be using HTMX. HTMX is a way to dynamically update content without reloading the page at all. I am sure you know the experience whenever you click "like" or "subscribe" , that's what HTMX gives us without the overhead of using 1 line of JavaScript. This course shows us a practical implementation of using HTMX not just for rating movies, but also sorting them, loading them, and doing much more.

The recommendation engine in Django is really a collection of 3 parts:

Web Process: Setup up Django to collect user's interest and provide recommendations once available.
Machine Learning Pipeline: Extract data from Django, transform it, and train a Collaborative Filtering model.
Worker Process: This is the glue. We'll use Celery to schedule/run the trained model predictions and update data for Django-related user recommendations.

What you'll learn:

Learn

• how to integrate Django & Celery
• Learn how to use HTMX with Django for Dynamic Loading (no JavaScript Needed)
• Training a Machine Learning Model with SurpriseML and an example in Keras
• Build a rating system in Django with dynamic rating buttons. These ratings can be used on any Django Model
• Learn how to run periodic background task and/or schedule functions to run exactly when needed
• How to perform batch inference effectively using Django for any large workloads and/or ML packages
• How to load large datasets into a SQL database through Django Models
• Where to find great datasets online
• How to implement an "infinite" review page that will always give a new item after rating.
• So much more!

Article source: https://dev.to

#django #python 

Установите Python 3.10 на Ubuntu 22.04

Установите Python 3.10 на Ubuntu 22.04; В этом руководстве мы узнаем, как установить Python 3.10 в системе Linux Ubuntu 22.04 с помощью командной строки.

Как установить Python 3.10 на Ubuntu 22.04

Используйте следующие шаги для установки и настройки системы Ubuntu 22.04:

Шаг 1. Откройте терминал или командную строку.

Прежде всего, ваш терминал или командная строка, нажав клавишу Ctrl+Alt+T:

Шаг 2 — Обновите пакет APT

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

sudo apt update

Шаг 3 – Добавьте deadsnakes PPA

На этом шаге выполните следующую команду на своем терминале, чтобы добавить deadsnakes PPA:

sudo add-apt-repository ppa:deadsnakes/ppa

При появлении запроса нажмите,  [Enter] чтобы продолжить.

Шаг 4 — Установите Python 3.10

На этом шаге выполните следующую команду на своем терминале, чтобы установить python 3.10 на Ubuntu:

sudo apt install python3.10

Шаг 4 — Проверка установки Python

На этом этапе выполните следующую команду на своем терминале, чтобы проверить установку Python 3.10 на Ubuntu 22.04:

python3 -V

Вывод будет:

Python 3.10.4

Обратите внимание, что самый простой способ — установить Python на Ubuntu 22.04.

Заключение

Благодаря этому руководству мы узнали, как установить Python 3.10 в систему Linux Ubuntu 22.04.

Оригинальный источник статьи: https://www.tutsmake.com/

#ubuntu #python 

Get Dictionary Values As A List in Python

When you need to get the values of a dictionary as a list, there are 4 solutions you can use:

1. Using the list() function and dict.values() method
2. Unpack the values as a list using the asterisk * symbol
3. Using a list comprehension
4. Using a for loop

I will show you how to use these 4 solutions in practice

1. Using list() and dict.values() method

To extract the values from a dictionary, you can use the dict.values() method. After that, you only need to call the list() function to convert the output to a list

Here’s an example:

organization = {
    'ceo': 'Nathan',
    'coo': 'Andy',
    'cfo': 'Johnny'
}

my_list = list(organization.values())

print(my_list)

Output:

['Nathan', 'Andy', 'Johnny']

As you can see, the solution successfully extracted the values from the dictionary.

2. Unpack the values as a list using the asterisk * symbol

As an alternative, you can also unpack the values as a list using the asterisk * symbol as follows:

organization = {
    'ceo': 'Nathan',
    'coo': 'Andy',
    'cfo': 'Johnny'
}

my_list = [*organization.values()]

print(my_list)

Output:

['Nathan', 'Andy', 'Johnny']

The starred expression unpacks the values from the dict_value iterable object, and we used a list [] to store the unpacked values.

3. Using a list comprehension

Another way to extract values from a dictionary is to use a list comprehension and the dict.values() method:

organization = {
    'ceo': 'Nathan',
    'coo': 'Andy',
    'cfo': 'Johnny'
}

my_list = [i for i in organization.values()]

print(my_list)

Output:

['Nathan', 'Andy', 'Johnny']

Similar to the starred expression, the list comprehension uses a for loop to extract each item in the dict_values object to a list.

4. Using a for loop

You can also use a for loop to iterate over the dictionary itself:

organization = {
    'ceo': 'Nathan',
    'coo': 'Andy',
    'cfo': 'Johnny'
}

my_list = []
for i in organization.values():
    my_list.append(i)

print(my_list)

Output:

['Nathan', 'Andy', 'Johnny']

In this solution, you need to create an empty list before running the for loop.

And that’s how you get the dictionary values as a list in Python. You might also want to check my other tutorial on getting the first key in a Python dictionary.

Original article source at: https://sebhastian.com/

#python #dictionary #values 

在 Ubuntu 22.04 上安装 Python 3.10

在ubuntu 22.04上安装python 3.10；通过本教程，我们将学习如何使用命令行在linux ubuntu 22.04系统上安装python 3.10。

如何在 Ubuntu 22.04 上安装 Python 3.10

使用以下步骤安装配置ubuntu 22.04系统：

第 1 步 - 打开终端或命令提示符

首先，在您的终端或命令提示符下按 Ctrl+Alt+T 键：

第 2 步 – 更新 APT 包

在这一步中，访问您的终端并执行以下命令来更新 Apt 包列表：

sudo apt update

第 3 步 – 添加 deadsnakes PPA

在此步骤中，在您的终端上执行以下命令以添加 deadsnakes PPA：

sudo add-apt-repository ppa:deadsnakes/ppa

出现提示时，按 [Enter] 继续。

第 4 步 – 安装 Python 3.10

在这一步中，在您的终端上执行以下命令，在 ubuntu 上安装 python 3.10：

sudo apt install python3.10

第 4 步 – 验证 Python 安装

在此步骤中，在您的终端上执行以下命令以验证 python 3.10 在 ubuntu 22.04 上的安装：

python3 -V

输出将是：

Python 3.10.4

请注意，最简单的方法是在 Ubuntu 22.04 上安装 python。

结论

通过本教程，我们学习了如何在linux ubuntu 22.04系统上安装python 3.10。

文章原文出处：https: //www.tutsmake.com/

#ubuntu #python 

Introdução ao Flask: um microframework Python

Neste tutorial do Python, aprenderemos sobre Getting Started with Flask, um Microframework do Python. apresentaremos o Flask, um popular microframework para Python que oferece uma alternativa ao gigante que é o Django.

O Flask foi projetado para ser leve e flexível, permitindo que os desenvolvedores criem aplicativos da Web com rapidez e facilidade. Neste artigo, abordaremos o que é o Flask, seus principais recursos, os benefícios de sua API simples, sua flexibilidade no suporte a extensões de terceiros, as extensões Flask mais comuns e quando é e quando não é um bom momento para usar Frasco.

O que é Frasco?

Flask é um micro framework web escrito em Python que é usado para desenvolver aplicações web. Ele foi desenvolvido com base em uma filosofia simples de manter as coisas simples e leves, oferecendo aos desenvolvedores apenas as ferramentas mais importantes necessárias para criar aplicativos da web sem complexidade desnecessária.

Ele é construído sobre o kit de ferramentas Werkzeug WSGI, que fornece a funcionalidade do servidor web necessária para lidar com solicitações e respostas, e o mecanismo de modelagem Jinja2, que dá ao Flask a capacidade de lidar com modelos HTML, permitindo que os desenvolvedores criem aplicativos dinâmicos da web.

Aqui estão alguns dos principais recursos do Flask que o tornam uma ótima estrutura para trabalhar:

• Possui uma API simples para criar rotas da web e lidar com solicitações.
• O mecanismo de modelagem Jinja oferece suporte para modelos HTML, permitindo que os desenvolvedores criem páginas da Web com facilidade.
• É altamente extensível, devido ao seu suporte para extensões de terceiros, para que um desenvolvedor possa instalar extensões de acordo com as necessidades do projeto.
• Ele vem com um servidor de desenvolvimento que facilita o teste e a depuração de aplicativos.

No geral, o Flask fornece uma estrutura poderosa, flexível e simples para criar aplicativos da Web. É uma boa escolha para desenvolvedores da Web novos e experientes e é uma das estruturas da Web mais populares no ecossistema de desenvolvimento da Web do Python.

Vantagens do Frasco

Vamos agora dar uma olhada mais detalhada em algumas das vantagens de usar o Flask no desenvolvimento.

Simplicidade . A filosofia de design do Flask enfatiza a simplicidade, o que facilita o entendimento e o uso por desenvolvedores de qualquer nível. Isso também significa que os desenvolvedores têm uma curva de aprendizado mínima, pois precisam aprender apenas alguns conceitos e APIs para começar a criar aplicativos da web.

Flexibilidade . A micro natureza do Flask — fornecendo apenas os principais recursos de uma estrutura da Web — dá aos desenvolvedores o poder de personalizá-lo e estendê-lo para atender às suas necessidades usando extensões do Flask ou bibliotecas de terceiros.

Documentação . A documentação do Flask é muito abrangente, com boa cobertura de tópicos básicos a avançados, tornando muito fácil para os desenvolvedores aprenderem a usar o framework.

Compatibilidade . O Flask é compatível com uma ampla gama de versões do Python, o que facilita o uso com as bases de código existentes do Python. Ele também oferece suporte para vários servidores da Web, o que facilita a implantação em várias plataformas de hospedagem.

Desenvolvimento rápido . A simplicidade e a flexibilidade do Flask reduzem o clichê necessário para configurar um aplicativo, permitindo que os desenvolvedores comecem rapidamente.

Na Web, o Flask é usado de várias maneiras interessantes. Alguns exemplos notáveis ​​são:

• PgAdmin . A interface de administração do Postgres é executada em uma instância Flask, dando aos desenvolvedores uma interface onde eles podem gerenciar seus bancos de dados Postgres.
• Twilio . Esta é uma plataforma de comunicação que utiliza Flask em várias de suas APIs.
• Pinterest . Este aplicativo de compartilhamento de fotos usa o Flask na pilha de desenvolvimento da Web, permitindo que sua equipe crie alguns recursos e integrações personalizados com facilidade.

Quando usar o frasco

A simplicidade e facilidade de uso do Flask o tornam uma excelente escolha para uma ampla gama de projetos da web:

• Prototipagem . Sua facilidade de uso e flexibilidade o tornam uma excelente escolha para a criação rápida de protótipos, permitindo que os desenvolvedores construam e testem novos recursos rapidamente.
• Criando APIs RESTful . Sua própria API simples facilita a criação e o manuseio de solicitações HTTP.
• Aplicativos de comércio eletrônico . Funciona bem para criar mercados online e plataformas de comércio eletrônico.
• Finanças . É útil para criar aplicativos financeiros, com gerenciamento de contas, processamento de transações e rastreamento de investimentos.
• IA . Ele oferece uma maneira útil e direta de criar e implantar modelos de treinamento de IA.

Quando Não Usar Frasco

Embora o Flask seja uma ótima estrutura e tenha várias vantagens e ótimos recursos, há situações em que esses recursos funcionam contra ele. Vamos explorar alguns dos projetos que se adequam melhor a outros tipos de frameworks.

Projetos que requerem funcionalidade integrada . Sendo um microframework, o Flask fornece apenas os bits principais necessários para criar um aplicativo da web. Se um projeto requer, digamos, uma interface administrativa, autenticação ou um ORM, o Django é uma opção melhor.

Projetos com rigorosos requisitos de segurança . Como o Flask é uma estrutura flexível, temos que contar com extensões de terceiros para implementar algum nível de segurança em nossos aplicativos. Embora isso certamente funcione, é melhor confiar em uma estrutura mais testada em batalha que adote uma abordagem mais segura, como Tornado ou Twisted.

Projetos que impõem algum padrão de codificação . Devido à flexibilidade do Flask, desenvolver aplicativos nele permite que os desenvolvedores criem aplicativos da maneira que acharem melhor. No entanto, estruturas como Django garantem que os desenvolvedores sigam uma convenção específica, o que significa que os desenvolvedores podem passar de um projeto para outro facilmente.

Configurando um Ambiente de Desenvolvimento Flask

Vejamos agora como começar a usar o Flask, desde a configuração do ambiente de desenvolvimento até a instalação e, finalmente, a criação de um aplicativo mínimo.

Pré-requisitos

O Python deve ser instalado na máquina de desenvolvimento. Aqui estão as instruções para isso (embora já possamos tê-lo instalado ).

Crie um ambiente virtual

Um ambiente virtual é um ambiente Python isolado onde podemos instalar pacotes para um determinado projeto sem afetar a instalação global do Python. (Aqui está uma discussão mais aprofundada sobre por que os ambientes virtuais são úteis .) Existem diferentes pacotes para criar ambientes virtuais em Python, como virtualenv, venv ou Conda.

Neste artigo, usaremos virtualenv. Podemos instalá-lo com o seguinte comando:

pip install virtualenv

Uma vez virtualenvinstalado, podemos criar um diretório onde residirá nosso aplicativo Flask. Podemos chamar o diretório como quisermos - exceto Flask, pois isso causará conflitos. Vamos chamar de nosso flask_intro:

mkdir flask_intro

Em seguida, mude para esse diretório para que possamos começar a usá-lo:

cd flask_intro

Nesse diretório, vamos agora criar nosso ambiente virtual, usando o seguinte comando:

virtualenv myenv

O comando acima cria um ambiente virtual e o chama myenv. Vamos ativá-lo para que possamos instalar o Flask nele. Para ativar o ambiente virtual no Linux ou macOS , use o seguinte comando:

. myenv/bin/activate

No Windows , use este comando:

. myenv\Scripts\activate

Assim que nosso ambiente virtual for ativado, ele mostrará o nome do ambiente virtual no prompt do shell, semelhante à saída abaixo:

(myenv)/~(path to your project directory)$

Dentro do nosso ambiente virtual ativado, podemos ir em frente e instalar o Flask, usando o seguinte comando:

pip install Flask

Depois que o Flask terminar de instalar, vamos em frente e criar um aplicativo mínimo. Vamos criar um módulo que irá armazenar nosso aplicativo Flask. Para simplificar, vamos chamá-lo de hello.py. No Linux ou macOS podemos usar o seguinte comando para criar o arquivo em nosso flask_introdiretório:

touch hello.py

O comando acima cria um arquivo chamado hello.py. Também poderíamos usar um ambiente de desenvolvimento para criar o arquivo. Uma vez que o arquivo foi criado, coloque o código abaixo nele e salve-o:

# hello.py
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
    return 'Hello, World!'

No código acima, importamos a Flaskclasse do flaskmódulo, depois criamos uma instância dela Flaskque chamamos appe passamos a __name__variável.

Então temos o decorador de rota @app.route(“\”), o que significa que a hello_world()função será acionada quando alguém visitar a rota raiz do nosso aplicativo assim que for executado.

Existem várias maneiras de executar o aplicativo, então vamos ver algumas delas. A primeira maneira é fornecer ao flaskcomando vários argumentos: --app, o nome do módulo que contém, nosso aplicativo Flask e, em seguida run, . Veja abaixo:

flask –app <the name of your module> run

Usando o exemplo acima para executar nosso aplicativo de exemplo:

flask –app hello run

Isso executará nosso aplicativo na porta padrão 5000para que o aplicativo esteja disponível em http://localhost:5000/ou em http://127.0.0.1:5000/. Se quisermos que o aplicativo esteja disponível em uma porta diferente, podemos especificar a porta usando a opção -pou --port. Por exemplo:

flask --app hello run --port=8080

Isso executará o servidor na porta 8080. A outra maneira de executar o aplicativo é apenas usando os flask runcomandos. Porém, para que possamos fazer isso, precisamos informar ao Flask o nome do módulo que irá conter a instância do Flask, e fazemos isso configurando a FLASK_APPvariável de ambiente. Portanto, em nosso caso, o aplicativo Flask está contido em um arquivo chamado hello.py. Então podemos configurar assim:

export FLASK_APP=hello

Agora que definimos a FLASK_APPvariável de ambiente, podemos executar o servidor de desenvolvimento da seguinte forma:

flask run

Com esse código, agora temos um aplicativo da Web em execução. Isso demonstra a filosofia central do Flask: não precisamos de muito código clichê para fazer as coisas funcionarem. No entanto, o aplicativo que configuramos acima não é muito funcional ou útil, pois apenas renderiza a string “Hello World!” em nossa página web. Para fazer algo mais útil, podemos recorrer aos modelos. Veremos como lidar com eles a seguir.

Modelos de Frasco

Os modelos Flask são uma maneira de criar páginas da Web dinâmicas que podem exibir conteúdo diferente com base em vários fatores, como dados de um banco de dados ou entrada do usuário. Os modelos no Flask são uma combinação de HTML e espaços reservados especiais chamados variáveis ​​de modelo que são substituídos por valores reais em tempo de execução.

Os modelos são armazenados no templatesdiretório. Portanto, para usar modelos, precisamos importar o render_template()método de flask. O render_template()método usa um nome de modelo e quaisquer dados opcionais que precisam ser passados ​​para o modelo.

Vejamos um exemplo de uma função que usa um template para renderizar uma página web:

# index.py
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def index():
    title = 'Welcome to my website!'
    message = 'This is an example of using Flask templates.'
    return render_template('index.html', title=title, message=message)

No exemplo acima, temos uma função view — index()— que é vinculada à URL raiz (“/”) pelo @app.route()decorador. A função tem duas variáveis, titlee message. Por fim, passamos o template index.htmlpara o render_template(), juntamente com as variáveis title​​e message.

Para que o código acima funcione, precisamos ter um index.htmltemplate residindo em um diretório de templates. Portanto, o modelo ficará mais ou menos assim:

# index.html
<!doctype html>
<html>
<head>
    <title>{{ title }}</title>
</head>
<body>
    <h1>{{ title }}</h1>
    <p>{{ message }}</p>
</body>
</html>

No index.htmlarquivo, os espaços reservados {{title}}e {{ message }}são substituídos pelos valores passados ​​para o modelo no render_template()método.

Os modelos também podem incluir lógica mais complexa, como ifinstruções e forloops, que permitem a geração de páginas mais dinâmicas.

Portanto, os modelos no Flask fornecem aos desenvolvedores uma opção muito poderosa para criar páginas da Web dinâmicas ricas em informações geradas pelo usuário.

Frasco de roteamento

A maioria dos aplicativos da Web terá mais de um URL, portanto, precisamos ter uma maneira de saber qual função manipula qual URL. No Flask, esse mapeamento é conhecido como roteamento — o processo de ligação ou mapeamento de URLs para exibir funções. A vinculação de URLs para exibir funções permite que o aplicativo lide com diferentes tipos de solicitações, como GET, POST, PUT, DELETEe muito mais. Ele também permite que o aplicativo lide com várias solicitações de diferentes clientes.

Para configurar rotas no Flask, usamos o route() decorator . O decorador vincula uma URL a uma função de exibição — portanto, quando um usuário visita uma URL que existe em nosso aplicativo, o Flask aciona a função de exibição associada para lidar com a solicitação.

Vejamos um exemplo:

# hello.py
from flask import Flask, render_template

app = Flask(__name__)

@app.route("/about")
def about():
    return "This is the about page"

No exemplo acima, definimos uma URL sobre ( /about). Quando o aplicativo recebe uma solicitação de aboutURL, o Flask chama a about()função, que retorna a string “Esta é a página sobre”.

Até agora, embora esses exemplos retornem páginas diferentes, todos eles usam apenas a GETsolicitação HTTP. Para poder lidar com qualquer solicitação específica, podemos especificar o método HTTP como um argumento opcional para o route()decorador.

Vejamos um exemplo de PUTrequisição:

from flask import Flask, request

app = Flask(__name__)

@app.route('/users/<int:user_id>', methods=['PUT'])
def update_user(user_id):
    # get the user data from the request body
    data = request.get_json()
    # do something with the user data, such as update the user in the database
    # ...
    # return a response indicating success or failure
    return {'message': f'User {user_id} updated successfully'}, 200

Neste exemplo, definimos uma rota que lida com uma PUTsolicitação para atualizar os detalhes do usuário, dados seus arquivos user_id. Usamos <int:user_id>na rota para indicar que o ID do usuário deve ser um número inteiro.

Na update_user()função, obtemos os dados do usuário do corpo da solicitação usando o request.get_json()método. Fazemos algo com os dados do usuário, como atualizar o usuário no banco de dados e, em seguida, retornamos uma resposta indicando sucesso ou falha junto com um código de status HTTP (neste caso, 200para mostrar o sucesso).

No geral, o roteamento permite que o Flask seja capaz de lidar com diferentes tipos de solicitações e permite que nosso aplicativo manipule e aja sobre os dados de maneira diferente, dependendo da URL que um usuário visita.

Formulários de Frasco e Validação

Além de exibir dados para os usuários, os modelos do Flask também podem receber informações dos usuários para processamento ou armazenamento posterior. Para isso, o Flask fornece suporte integrado para processar formulários HTML e manipular a entrada do usuário. Os formulários Flask são baseados na biblioteca WTForms, que fornece uma maneira flexível e poderosa de lidar com dados de formulários e realizar validações. No entanto, a biblioteca não faz parte da instalação padrão do Flask, portanto, precisamos instalá-la usando o seguinte comando:

pip install WTForms

Uma vez instalado o WTForms, para usar formulários no Flask precisamos definir uma classe de formulário que herdará de flask_wtf.FlaskForm. A classe conterá os campos que estarão no formulário e quaisquer regras de validação que devem ser aplicadas a eles.

Vejamos um exemplo de formulário de login:

# forms.py
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, Email, Length

class LoginForm(FlaskForm):
    email = StringField('Email', validators=[DataRequired(), Email()])
    password = PasswordField('Password', validators=[DataRequired(), Length(min=6)])
    submit = SubmitField('Log In')

No exemplo acima, definimos um formulário de login com dois campos — emaile password— e um botão de envio. Também temos um validatorsargumento usado para especificar regras de validação para cada campo. Por exemplo, neste caso, exigimos que o emailcampo contenha um endereço de e-mail válido e que o passwordcampo contenha uma senha com no mínimo seis caracteres.

Depois de definir a classe de formulário, podemos usá-la na função de exibição de login para renderizar o formulário e processar os dados do formulário enviados pelo usuário. Vejamos um exemplo da função view:

# views.py
from flask import render_template, request
from .forms import LoginForm

@app.route('/login', methods=['GET', 'POST'])
def login():
    form = LoginForm()
    if form.validate_on_submit():
        email = form.email.data
        password = form.password.data
        # do something with the form data
    return render_template('login.html', form=form)

No exemplo acima, temos uma loginview que aceita dois métodos HTTP ( GETe POST), então quando o usuário acessa a URL de um navegador o LoginFormé renderizado como um formulário HTML usando o render_templatemétodo, e quando um usuário envia o formulário verificamos se o formulário é válido usando o validate_on_submitmétodo. Se o formulário for válido, acessamos o e-mail e a senha.

O login.htmlformulário poderia ser mais ou menos assim:

# login.html
<h1>Login</h1>
<form method="POST">
  {{ form.csrf_token }}
  <div>
    {{ form.email.label }} {{ form.email() }}
    {% for error in form.email.errors %}
    <span style="color: red;">[{{ error }}]</span>
    {% endfor %}
  </div>
  <div>
    {{ form.password.label }} {{ form.password() }}
    {% for error in form.password.errors %}
      <span style="color: red;">[{{ error }}]</span>
    {% endfor %}
  </div>
  {{ form.submit() }}
</form>

O modelo acima renderizará os campos emaile password, juntamente com seus rótulos, e um botão de envio com o texto “Login”. O form.csrf_tokencampo é incluído para evitar ataques de falsificação de solicitação entre sites (CSRF). Os {% for %}loops são usados ​​para exibir quaisquer erros de validação que possam ocorrer.

Ao usar os formulários do Flask, temos uma maneira poderosa de lidar com a entrada do usuário e podemos validar os dados que eles inserem.

Extensões de balão

Como vimos, o Flask é um microframework que inclui apenas as partes mais importantes necessárias para criar um aplicativo da web. No entanto, se precisarmos adicionar funcionalidades que não são oferecidas de fábrica pelo Flask, precisamos adicionar pacotes à instalação. As extensões do Flask são a forma como fornecemos essa funcionalidade adicional. Podemos simplesmente instalar o pacote que precisamos. Existem muitas extensões feitas pela comunidade Flask.

Aqui estão alguns dos mais populares:

• Flask-SQLAlchemy : fornece integração com o kit de ferramentas SQLAlchemy que facilita a interação com bancos de dados.
• Flask-Login : fornece autenticação de usuário e gerenciamento de sessão para Flask.
• Flask-Mail : fornece uma interface simples para enviar e-mails do Flask.

Existem centenas de extensões feitas pela comunidade Flask para lidar com diferentes funcionalidades. Usar as extensões geralmente é simples. Primeiro, precisamos instalar a extensão que queremos usando o pip.

Vamos ver um exemplo de uso do Flask-SQLAlchemy. Primeiro, precisamos instalá-lo:

pip install flask-sqlalchemy

Em seguida, precisamos configurá-lo. Por exemplo:

# sqlalchemy_example.py
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'
db = SQLAlchemy(app)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

    def __repr__(self):
        return '<User %r>' % self.username

No exemplo acima, temos um Usermodelo com um campo usernamee email. Também configuramos SQLALCHEMY_DATABASE_URI, indicando que estamos usando um banco de dados SQLite localizado em example.db. Com esse conjunto, agora temos acesso ao dbobjeto que nos permite interagir com o banco de dados. Por exemplo, poderíamos criar um novo usuário e adicioná-lo ao banco de dados, assim:

#views.py 
from app import db, User

user = User(username='john', email='john@example.com')
db.session.add(user)
db.session.commit()

Com as extensões do Flask, nosso aplicativo pode ter mais funcionalidade do que normalmente teria com a implementação principal do Flask.

Conclusão

Neste artigo, apresentamos o Flask, um framework web leve e flexível para Python. Discutimos as vantagens de usar o Flask para desenvolvimento web, incluindo sua simplicidade, flexibilidade e facilidade de uso. Também abordamos como configurar um ambiente de desenvolvimento, criar rotas, usar modelos, manipular formulários e usar extensões como Flask-SQLAlchemy.

Para resumir, o Flask é uma ótima opção para criar aplicativos da Web de qualquer tamanho, desde pequenos projetos pessoais até aplicativos comerciais de grande escala. É fácil de aprender e usar, mas também oferece recursos avançados por meio de suas diversas extensões.

Fonte do artigo: https://www.sitepoint.com

#flask  #python