1685644080
在本 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
1685641380
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.
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.
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:
r = requests.post('https://httpbin.org/post', data={'key': 'value'})
r = requests.put('https://httpbin.org/put', data={'key': 'value'})
r = requests.delete('https://httpbin.org/delete')
First, let’s make a GET request,
r = requests.get('https://codesource.io/')
Some basic and important methods for Response objects,
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.
To get the URL used in your get request,
print(r.url)
#Output:- https://codesource.io/
To get the text from a get request Response object,
print(r.text)
To get the content of your request in binary,
print(r.content)
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())
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.
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.
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"
]
},
...
} .
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:- []
Original article source at: https://codesource.io/
1685631856
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.
Đầ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
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:
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
# 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
Để 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
1685626200
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
Fonte do artigo: https://dev.to
1685624640
Чтобы проверить, имеет ли объект определенный атрибут или нет, вы можете использовать функцию 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/
1685620874
要检查对象是否具有某个属性,可以使用该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/
1685620109
Когда вам нужно получить значения словаря в виде списка, вы можете использовать 4 решения:
Я покажу вам, как использовать эти 4 решения на практике.
Чтобы извлечь значения из словаря, вы можете использовать dict.values()метод. После этого вам нужно только вызвать list()функцию для преобразования вывода в список
Вот пример:
organization = {
'ceo': 'Nathan',
'coo': 'Andy',
'cfo': 'Johnny'
}
my_list = list(organization.values())
print(my_list)
Выход:
['Nathan', 'Andy', 'Johnny']
Как видите, решение успешно извлекло значения из словаря.
В качестве альтернативы вы также можете распаковать значения в виде списка, используя *символ звездочки, как показано ниже:
organization = {
'ceo': 'Nathan',
'coo': 'Andy',
'cfo': 'Johnny'
}
my_list = [*organization.values()]
print(my_list)
Выход:
['Nathan', 'Andy', 'Johnny']
Выражение со звездочкой распаковывает значения из dict_valueитерируемого объекта, и мы использовали список []для хранения распакованных значений.
Другой способ извлечь значения из словаря — использовать понимание списка и метод 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объекте в список.
Вы также можете использовать 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/
1685618940
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.
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
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
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
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
1685616720
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/
1685616420
当您需要将字典的值作为列表获取时,您可以使用 4 种解决方案:
我将向您展示如何在实践中使用这 4 种解决方案
要从字典中提取值,您可以使用该dict.values()方法。之后,你只需要调用list()函数将输出转换为列表
这是一个例子:
organization = {
'ceo': 'Nathan',
'coo': 'Andy',
'cfo': 'Johnny'
}
my_list = list(organization.values())
print(my_list)
输出:
['Nathan', 'Andy', 'Johnny']
如您所见,该解决方案成功地从字典中提取了值。
或者,您也可以使用星*号将值解压缩为列表,如下所示:
organization = {
'ceo': 'Nathan',
'coo': 'Andy',
'cfo': 'Johnny'
}
my_list = [*organization.values()]
print(my_list)
输出:
['Nathan', 'Andy', 'Johnny']
带星号的表达式从可迭代对象中解压值dict_value,我们使用一个列表[]来存储解压后的值。
从字典中提取值的另一种方法是使用列表理解和方法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到列表中。
您还可以使用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/
1685615880
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
Article source: https://dev.to
1685615880
Установите Python 3.10 на Ubuntu 22.04; В этом руководстве мы узнаем, как установить Python 3.10 в системе Linux Ubuntu 22.04 с помощью командной строки.
Используйте следующие шаги для установки и настройки системы Ubuntu 22.04:
Прежде всего, ваш терминал или командная строка, нажав клавишу Ctrl+Alt+T:
На этом шаге зайдите в свой терминал и выполните следующую команду, чтобы обновить список пакетов Apt:
sudo apt update
На этом шаге выполните следующую команду на своем терминале, чтобы добавить deadsnakes PPA:
sudo add-apt-repository ppa:deadsnakes/ppa
При появлении запроса нажмите, [Enter] чтобы продолжить.
На этом шаге выполните следующую команду на своем терминале, чтобы установить python 3.10 на Ubuntu:
sudo apt install python3.10
На этом этапе выполните следующую команду на своем терминале, чтобы проверить установку 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/
1685612527
When you need to get the values of a dictionary as a list, there are 4 solutions you can use:
list()
function and dict.values()
method*
symbolfor
loopI will show you how to use these 4 solutions in practice
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.
*
symbolAs 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.
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.
for
loopYou 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/
1685612170
在ubuntu 22.04上安装python 3.10;通过本教程,我们将学习如何使用命令行在linux ubuntu 22.04系统上安装python 3.10。
使用以下步骤安装配置ubuntu 22.04系统:
首先,在您的终端或命令提示符下按 Ctrl+Alt+T 键:
在这一步中,访问您的终端并执行以下命令来更新 Apt 包列表:
sudo apt update
在此步骤中,在您的终端上执行以下命令以添加 deadsnakes PPA:
sudo add-apt-repository ppa:deadsnakes/ppa
出现提示时,按 [Enter] 继续。
在这一步中,在您的终端上执行以下命令,在 ubuntu 上安装 python 3.10:
sudo apt install python3.10
在此步骤中,在您的终端上执行以下命令以验证 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/
1685611620
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.
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:
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.
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:
A simplicidade e facilidade de uso do Flask o tornam uma excelente escolha para uma ampla gama de projetos da web:
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.
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.
O Python deve ser instalado na máquina de desenvolvimento. Aqui estão as instruções para isso (embora já possamos tê-lo instalado ).
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.
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 titlee 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.
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.
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.
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:
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.
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