Real Python

Using Pandas to Make a Gradebook in Python

2021-06-15T14:00:00+00:00

One of the jobs that all teachers have in common is evaluating students. Whether you use exams, homework assignments, quizzes, or projects, you usually have to turn students’ scores into a letter grade at the end of the term. This often involves a bunch of calculations that you might do in a spreadsheet. Instead, you can consider using Python and pandas.

In this course, you’ll learn how to:

Load and merge data from multiple sources with pandas
Filter and group data in a pandas DataFrame
Calculate and plot grades in a pandas DataFrame

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Python Practice Problems: Parsing CSV Files

2021-06-14T20:08:22+00:00

Are you a developer looking for some practice with comma-separated values (CSV) files before an upcoming interview? This tutorial will lead you through a series of Python CSV practice problems to help you get ready.

This tutorial is aimed at intermediate Python developers. It assumes a basic knowledge of Python and working with CSV files. Like other practice problem tutorials, each of the problems listed here shows the problem description. You’ll see the problem statement first and then have a chance to develop your own solution.

In this tutorial, you’ll explore:

Writing code for working with CSV files
Doing test-driven development with pytest
Discussing your solutions and possible enhancements
The trade-offs between the built-in CSV module and pandas

You can get skeleton code with failing unit tests for each of the problems you’ll see in this tutorial by clicking the link below:

Get the Source Code: Click here to get the source code you’ll use to practice parsing CSV files in this tutorial.

Python CSV Parsing: Football Scores

Your first problem deals with English Premier League team standings. You don’t need any special football knowledge to solve this, just Python!

As you work through the problem, try to write more unit tests for each bit of functionality and then write the functionality to make the tests pass. This is known as test-driven development, and it can be a great way to show off not only your coding but also your testing chops!

Problem Description

For this round of the problem, stick to the standard library csv module. You’ll get another shot at it using pandas later. Here’s your first problem:

Find the Minimum Goal Differential

Write a program that takes a filename on the command line and processes the contents of a CSV file. The contents will be the end-of-season football standings for the English Premier League. Your program should determine which team had the smallest goal differential that season.

The first line of the CSV file will be column headers, with each subsequent line showing the data for one team:
Team,Games,Wins,Losses,Draws,Goals For,Goals Against
Arsenal,38,26,9,3,79,36
The columns labeled Goals For and Goals Against contain the total number of goals scored for and against each team in that season. (So Arsenal scored 79 goals and had 36 goals scored against them.)

Write a program to read the file, then print the name of the team with the smallest difference in Goals For and Goals Against. Create unit tests with pytest to test your program.

There is a single unit test supplied in the skeleton code that tests the problem statement that you’ll see later. You can add more as you write your solution. There are also two pytest fixtures given:

# test_football_v1.py
import pytest
import football_v1 as fb

@pytest.fixture
def mock_csv_data():
    return [
        "Team,Games,Wins,Losses,Draws,Goals For,Goals Against",
        "Liverpool FC, 38, 32, 3, 3, 85, 33",
        "Norwich City FC, 38, 5, 27, 6, 26, 75",
    ]

@pytest.fixture
def mock_csv_file(tmp_path, mock_csv_data):
    datafile = tmp_path / "football.csv"
    datafile.write_text("\n".join(mock_csv_data))
    return str(datafile)

Read the full article at https://realpython.com/python-interview-problem-parsing-csv-files/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #64: Detecting Deforestation With Python & Using GraphQL With Django and Vue

2021-06-11T12:00:00+00:00

Are you looking for an in-depth data science project to practice your skills on? Perhaps you would like to add new tools to your Python web development projects instead? This week on the show, David Amos is back, and he's brought another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Python's filter(): Extract Values From Iterables

2021-06-09T14:00:00+00:00

Python’s filter() is a built-in function that allows you to process an iterable and extract those items that satisfy a given condition. This process is commonly known as a filtering operation. With filter(), you can apply a filtering function to an iterable and produce a new iterable with the items that satisfy the condition at hand. In Python, filter() is one of the tools you can use for functional programming.

In this tutorial, you’ll learn how to:

Use Python’s filter() in your code
Extract needed values from your iterables
Combine filter() with other functional tools
Replace filter() with more Pythonic tools

With this knowledge, you’ll be able to use filter() effectively in your code. Alternatively, you have the choice of using list comprehensions or generator expressions to write more Pythonic and readable code.

To better understand filter(), it would be helpful for you to have some previous knowledge on iterables, for loops, functions, and lambda functions.

Free Bonus: 5 Thoughts On Python Mastery, a free course for Python developers that shows you the roadmap and the mindset you’ll need to take your Python skills to the next level.

Coding With Functional Style in Python

Functional programming is a paradigm that promotes using functions to perform almost every task in a program. A pure functional style relies on functions that don’t modify their input arguments and don’t change the program’s state. They just take a specific set of arguments and return the same result every time. These kinds of functions are known as pure functions.

In functional programming, functions often operate on arrays of data, transform them, and produce new arrays with added features. There are three fundamental operations in functional programming:

Mapping applies a transformation function to an iterable and produces a new iterable of transformed items.
Filtering applies a predicate, or Boolean-valued, function to an iterable and generates a new iterable containing the items that satisfy the Boolean condition.
Reducing applies a reduction function to an iterable and returns a single cumulative value.

Python isn’t heavily influenced by functional languages but by imperative ones. However, it provides several features that allow you to use a functional style:

Anonymous functions
A map() function
A filter() function
A reduce() function

Functions in Python are first-class objects, which means that you can pass them around as you’d do with any other object. You can also use them as arguments and return values of other functions. Functions that accept other functions as arguments or that return functions (or both) are known as higher-order functions, which are also a desirable feature in functional programming.

In this tutorial, you’ll learn about filter(). This built-in function is one of the more popular functional tools of Python.

Understanding the Filtering Problem

Say you need to process a list of numbers and return a new list containing only those numbers greater than 0. A quick way to approach this problem is to use a for loop like this:

>>>

>>> numbers = [-2, -1, 0, 1, 2]

>>> def extract_positive(numbers):
...     positive_numbers = []
...     for number in numbers:
...         if number > 0:  # Filtering condition
...             positive_numbers.append(number)
...     return positive_numbers
...

>>> extract_positive(numbers)
[1, 2]

The loop in extract_positive() iterates through numbers and stores every number greater than 0 in positive_numbers. The conditional statement filters out the negative numbers and 0. This kind of functionality is known as a filtering.

Filtering operations consist of testing each value in an iterable with a predicate function and retaining only those values for which the function produces a true result. Filtering operations are fairly common in programming, so most programming languages provide tools to approach them. In the next section, you’ll learn about Python’s way to filter iterables.

Getting Started With Python’s `filter()`

Python provides a convenient built-in function, filter(), that abstracts out the logic behind filtering operations. Here’s its signature:

filter(function, iterable)

The first argument, function, must be a single-argument function. Typically, you provide a predicate (Boolean-valued) function to this argument. In other words, you provide a function that returns either True or False according to a specific condition.

This function plays the role of a decision function, also known as a filtering function, because it provides the criteria to filter out unwanted values from the input iterable and to keep those values that you want in the resulting iterable. Note that the term unwanted values refers to those values that evaluate to false when filter() processes them using function.

Note: The first argument to filter() is a function object, which means that you need to pass a function without calling it with a pair of parentheses.

Read the full article at https://realpython.com/python-filter-function/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Python Basics: Setting Up Python

2021-06-08T14:00:00+00:00

Setting up Python is the first step to becoming a Python programmer. In this course, you’ll learn how to download and install Python for Windows, macOS, and Ubuntu Linux and how to open Python’s Integrated Development and Learning Environment, IDLE.

There are many ways to install Python. You can download official Python distributions from Python.org, install from a package manager, and even install specialized distributions for scientific computing, Internet of Things, and embedded systems. This course focuses on official distributions, as they’re generally the best option for getting started with learning to program in Python.

This course can be enjoyed alone or as an accompaniment to Python Basics: A Practical Introduction to Python 3.

In this course, you’ll learn how to:

Install Python on Windows, macOS, and Linux
Open IDLE, Python’s integrated development and learning environment

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Python Community Interview With Sebastián Ramírez

2021-06-07T14:00:00+00:00

Today, I’m joined by Sebastián Ramírez, a software developer at Explosion AI. He is also the creator of the popular frameworks FastAPI and Typer. In this interview, we discuss typing in Python, his motivations for creating FastAPI and the future of the framework, and much more. Without further ado, let’s get into it.

Ricky: Thanks for joining me, Sebastián. I’d like to start with the same questions I do with all my guests: how did you get into programming, and when did you start using Python?

Sebastián: Thanks for having me 😁

I got into coding when I was about fifteen, trying to build a website for my parents’ business. The first actual “code” I wrote was some JavaScript inside an HTML with an alert("Hello World"). I still remember the rush of excitement seeing that little alert message and the powerful feeling of thinking that I had coded it.

I was afraid to learn any other language for years, thinking I had to “at least” master JavaScript first. Several years later, one of the many online courses I was taking at the time required Python for controlling an AI Pac-Man and other things. The course had a single long-page tutorial with just the basics of Python, and that was enough for that course. I really wanted to try it, so I went ahead with just that basic tutorial.

Of course, I rapidly fell in love with Python and wished I had started earlier 😅

Ricky: You’re currently a software developer at Explosion AI, the company behind the popular natural language processing (NLP) framework spaCy. Can you speak a little about what your day-to-day looks like? What interests you about artificial intelligence and machine learning, and what tooling has Explosion AI created to help developers push the boundaries in both fields?

Sebastián: Yep, Explosion is mostly known for spaCy, the open source NLP toolkit. They also created Prodigy, a commercial, scriptable tool for efficiently annotating machine learning datasets. My work has been mainly on Prodigy Teams, a cloud version of Prodigy focused on teams with multiple users. As the product is very privacy-centric, making a teams/cloud version has many particular challenges.

Nevertheless, I recently decided to leave the company. I’m currently (as of the time I’m writing this) finishing all the vacations I had accumulated 😁

My plan is to arrange a way to dedicate a high percentage of my working time to FastAPI, Typer, and the other open source projects, while probably doing some consulting helping other teams and companies to make it all sustainable 🚀

Read the full article at https://realpython.com/interview-sebastian-ramirez/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #63: Create Web Applications Using Only Python With Anvil

2021-06-04T12:00:00+00:00

What if you could create an application and deploy it to the web with just Python? Wouldn't it be nice to skip the additional full-stack development steps of learning three different languages in addition to Python? That's the idea behind Anvil. This week on the show, we have Meredydd Luff, co-founder of Anvil.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Context Managers and Python's with Statement

2021-06-02T14:00:00+00:00

The with statement in Python is a quite useful tool for properly managing external resources in your programs. It allows you to take advantage of existing context managers to automatically handle the setup and teardown phases whenever you’re dealing with external resources or with operations that require those phases.

Besides, the context management protocol allows you to create your own context managers so you can customize the way you deal with system resources. So, what’s the with statement good for?

In this tutorial, you’ll learn:

What the Python with statement is for and how to use it
What the context management protocol is
How to implement your own context managers

With this knowledge, you’ll write more expressive code and avoid resource leaks in your programs. The with statement helps you implement some common resource management patterns by abstracting their functionality and allowing them to be factored out and reused.

Free Download: Get a sample chapter from Python Tricks: The Book that shows you Python’s best practices with simple examples you can apply instantly to write more beautiful + Pythonic code.

Managing Resources in Python

One common problem you’ll face in programming is how to properly manage external resources, such as files, locks, and network connections. Sometimes, a program will retain those resources forever, even if you no longer need them. This kind of issue is called a memory leak because the available memory gets reduced every time you create and open a new instance of a given resource without closing an existing one.

Managing resources properly is often a tricky problem. It requires both a setup phase and a teardown phase. The latter phase requires you to perform some cleanup actions, such as closing a file, releasing a lock, or closing a network connection. If you forget to perform these cleanup actions, then your application keeps the resource alive. This might compromise valuable system resources, such as memory and network bandwidth.

For example, a common problem that can arise when developers are working with databases is when a program keeps creating new connections without releasing or reusing them. In that case, the database back end can stop accepting new connections. This might require an admin to log in and manually kill those stale connections to make the database usable again.

Another frequent issue shows up when developers are working with files. Writing text to files is usually a buffered operation. This means that calling .write() on a file won’t immediately result in writing text to the physical file but to a temporary buffer. Sometimes, when the buffer isn’t full and developers forget to call .close(), part of the data can be lost forever.

Another possibility is that your application runs into errors or exceptions that cause the control flow to bypass the code responsible for releasing the resource at hand. Here’s an example in which you use open() to write some text to a file:

file = open("hello.txt", "w")
file.write("Hello, World!")
file.close()

This implementation doesn’t guarantee the file will be closed if an exception occurs during the .write() call. In this case, the code will never call .close(), and therefore your program might leak a file descriptor.

In Python, you can use two general approaches to deal with resource management. You can wrap your code in:

A try … finally construct
A with construct

The first approach is quite general and allows you to provide setup and teardown code to manage any kind of resource. However, it’s a little bit verbose. Also, what if you forget any cleanup actions?

The second approach provides a straightforward way to provide and reuse setup and teardown code. In this case, you’ll have the limitation that the with statement only works with context managers. In the next two sections, you’ll learn how to use both approaches in your code.

The `try` … `finally` Approach

Working with files is probably the most common example of resource management in programming. In Python, you can use a try … finally statement to handle opening and closing files properly:

# Safely open the file
file = open("hello.txt", "w")

try:
    file.write("Hello, World!")
finally:
    # Make sure to close the file after using it
    file.close()

In this example, you need to safely open the file hello.txt, which you can do by wrapping the call to open() in a try … except statement. Later, when you try to write to file, the finally clause will guarantee that file is properly closed, even if an exception occurs during the call to .write() in the try clause. You can use this pattern to handle setup and teardown logic when you’re managing external resources in Python.

The try block in the above example can potentially raise exceptions, such as AttributeError or NameError. You can handle those exceptions in an except clause like this:

# Safely open the file
file = open("hello.txt", "w")

try:
    file.write("Hello, World!")
except Exception as e:
    print(f"An error occurred while writing to the file: {e}")
finally:
    # Make sure to close the file after using it
    file.close()

In this example, you catch any potential exceptions that can occur while writing to the file. In real-life situations, you should use a specific exception type instead of the general Exception to prevent unknown errors from passing silently.

Read the full article at https://realpython.com/python-with-statement/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Explore Your Dataset With Pandas

2021-06-01T14:00:00+00:00

Do you have a large dataset that’s full of interesting insights, but you’re not sure where to start exploring it? Has your boss asked you to generate some statistics from it, but they’re not so easy to extract? These are precisely the use cases where Pandas and Python can help you! With these tools, you’ll be able to slice a large dataset down into manageable parts and glean insight from that information.

In this course, you’ll learn how to:

Calculate metrics about your data
Perform basic queries and aggregations
Discover and handle incorrect data, inconsistencies, and missing values
Visualize your data with plots

You’ll also learn about the differences between the main data structures that Pandas and Python use.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Python News: What's New From May 2021?

2021-05-31T14:00:00+00:00

If you want to get up to speed on what happened in the world of Python in May 2021, then you’ve come to the right place to get your news!

May was a month of big events. The Pallets Projects, home to popular frameworks like Flask and Click, released new major versions of all six of its core projects. The Python Software Foundation (PSF) hosted PyCon US 2021, a virtual conference that delivered an authentic in-person experience.

Let’s dive into the biggest Python news from the past month!

Free Download: Get a sample chapter from CPython Internals: Your Guide to the Python 3 Interpreter showing you how to unlock the inner workings of the Python language, compile the Python interpreter from source code, and participate in the development of CPython.

In last month’s news roundup, we covered how Google and Bloomberg Engineering became the first two PSF Visionary Sponsors. At the end of April, the PSF also announced that Microsoft increased its support to the Visionary level.

Microsoft is directing its financial support to the Python Packaging Working Group:

As part of our $150K financial sponsorship of the PSF, we will be focusing our funds to the Packaging Working Group to help with development costs for further improvements to PyPI and the packaging ecosystem. With recently disclosed security vulnerabilities, trusted supply chain is a critical issue for us and the Python community, and we are excited to help contribute to long-term improvements. (Source)

In addition to its Visionary sponsor status, Microsoft also has five Python core developers on staff that contribute to Python part-time: Brett Cannon, Steve Dower, Guido van Rossum, Eric Snow, and Barry Warsaw.

For more information about Microsoft’s support for Python and the PSF, check out its official announcement.

Check out Steve Dower’s account to get an inside scoop on how Microsoft’s position toward Python has changed over the years. You can also listen to Brett Cannon share his experience with Python at Microsoft on the Real Python Podcast.

Pallets Releases New Major Versions of All Core Projects

Two years of hard work from the Pallets team and its many open source contributors has culminated in the release of new major versions for all six of its core projects:

All six projects have dropped support for Python 2 and Python 3.5, making Python 3.6 the minimum supported version. Previously deprecated code has been removed, and some new deprecations have been added.

Some of the major changes affecting all six projects include:

Read the full article at https://realpython.com/python-news-may-2021/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #62: Selecting the Ideal Data Structure & Unravelling Python's "pass" and "with"

2021-05-28T12:00:00+00:00

How do you know you're using the correct data structure for your Python project? There are so many built into Python and even more that are importable from the collections module. This week on the show, David Amos is back, and he's brought another batch of PyCoder's Weekly articles and projects. We discuss a recent three-part video course on selecting the ideal data structure.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Visualizing Data in Python Using plt.scatter()

2021-05-26T14:00:00+00:00

An important part of working with data is being able to visualize it. Python has several third-party modules you can use for data visualization. One of the most popular modules is Matplotlib and its submodule pyplot, often referred to using the alias plt. Matplotlib provides a very versatile tool called plt.scatter() that allows you to create both basic and more complex scatter plots.

Below, you’ll walk through several examples that will show you how to use the function effectively.

In this tutorial you’ll learn how to:

Create a scatter plot using plt.scatter()
Use the required and optional input parameters
Customize scatter plots for basic and more advanced plots
Represent more than two dimensions on a scatter plot

To get the most out of this tutorial, you should be familiar with the fundamentals of Python programming and the basics of NumPy and its ndarray object. You don’t need to be familiar with Matplotlib to follow this tutorial, but if you’d like to learn more about the module, then check out Python Plotting With Matplotlib (Guide).

Free Bonus: Click here to get access to a free NumPy Resources Guide that points you to the best tutorials, videos, and books for improving your NumPy skills.

Creating Scatter Plots

A scatter plot is a visual representation of how two variables relate to each other. You can use scatter plots to explore the relationship between two variables, for example by looking for any correlation between them.

In this section of the tutorial, you’ll become familiar with creating basic scatter plots using Matplotlib. In later sections, you’ll learn how to further customize your plots to represent more complex data using more than two dimensions.

Getting Started With `plt.scatter()`

Before you can start working with plt.scatter() , you’ll need to install Matplotlib. You can do so using Python’s standard package manger, pip, by running the following command in the console :

$ python -m pip install matplotlib

Now that you have Matplotlib installed, consider the following use case. A café sells six different types of bottled orange drinks. The owner wants to understand the relationship between the price of the drinks and how many of each one he sells, so he keeps track of how many of each drink he sells every day. You can visualize this relationship as follows:

import matplotlib.pyplot as plt

price = [2.50, 1.23, 4.02, 3.25, 5.00, 4.40]
sales_per_day = [34, 62, 49, 22, 13, 19]

plt.scatter(price, sales_per_day)
plt.show()

In this Python script, you import the pyplot submodule from Matplotlib using the alias plt. This alias is generally used by convention to shorten the module and submodule names. You then create lists with the price and average sales per day for each of the six orange drinks sold.

Finally, you create the scatter plot by using plt.scatter() with the two variables you wish to compare as input arguments. As you’re using a Python script, you also need to explicitly display the figure by using plt.show().

When you’re using an interactive environment, such as a console or a Jupyter Notebook, you don’t need to call plt.show(). In this tutorial, all the examples will be in the form of scripts and will include the call to plt.show().

Here’s the output from this code:

This plot shows that, in general, the more expensive a drink is, the fewer items are sold. However, the drink that costs $4.02 is an outlier, which may show that it’s a particularly popular product. When using scatter plots in this way, close inspection can help you explore the relationship between variables. You can then carry out further analysis, whether it’s using linear regression or other techniques.

Comparing `plt.scatter()` and `plt.plot()`

You can also produce the scatter plot shown above using another function within matplotlib.pyplot. Matplotlib’s plt.plot() is a general-purpose plotting function that will allow you to create various different line or marker plots.

You can achieve the same scatter plot as the one you obtained in the section above with the following call to plt.plot(), using the same data:

plt.plot(price, sales_per_day, "o")
plt.show()

In this case, you had to include the marker "o" as a third argument, as otherwise plt.plot() would plot a line graph. The plot you created with this code is identical to the plot you created earlier with plt.scatter().

Read the full article at https://realpython.com/visualizing-python-plt-scatter/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

How to Set Up a Django Project

2021-05-25T14:00:00+00:00

When you start building any new Django web application, there’s a basic setup you need to tackle first. This course outlines the necessary steps to set up a Django project.

During this course, you’ll focus on the initial steps you’ll need to take to start a new web application. You should first have Python installed and you should know how to work with virtual environments and Python’s package manager, pip. You won’t need much programming knowledge to follow along with this setup, though you’ll need to know some Python to develop your project further afterwards.

After finishing this course, you’ll know how to:

Set up a virtual environment
Install Django
Pin your project dependencies
Set up a Django project
Start a Django app

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Build a Blog Using Django, Vue, and GraphQL

2021-05-24T14:00:00+00:00

Are you a regular Django user? Do you find yourself wanting to decouple your back end and front end? Do you want to handle data persistence in the API while displaying the data in a single-page app (SPA) in the browser using a client-side framework like React or Vue? You’re in luck. This tutorial will take you through the process of building a Django blog back end and a Vue front end, using GraphQL to communicate between them.

Projects are an effective way to learn and solidify concepts. This tutorial is structured as a step-by-step project so you can learn in a hands-on way and take breaks as needed.

In this tutorial, you’ll learn how to:

Translate your Django models into a GraphQL API
Run the Django server and a Vue application on your computer at the same time
Administer your blog posts in the Django admin
Consume a GraphQL API in Vue to show data in the browser

You can download all the source code you’ll use to build your Django blog application by clicking the link below:

Get the Source Code: Click here to get the source code you’ll use to build a blog application with Django, Vue, and GraphQL in this tutorial.

Demo: A Django Blog Admin, a GraphQL API, and a Vue Front End

Blog applications are a common starter project because they involve create, read, update, and delete (CRUD) operations. In this project, you’ll use the Django admin to do the heavy CRUD lifting and focus on providing a GraphQL API for your blog data.

Here’s a demonstration of the completed project in action:

Next, you’ll make sure you have all the necessary background information and tools before diving into building your blog application.

Project Overview

You’ll create a small blogging application with some rudimentary features. Authors can write many posts. Posts can have many tags and can be either published or unpublished.

You’ll build the back end of this blog in Django, complete with an admin for adding new blog content. Then you’ll expose the content data as a GraphQL API and use Vue to display that data in the browser. You’ll accomplish this in several high-level steps:

Set up the Django blog
Create the Django blog admin
Set up Graphene-Django
Set up django-cors-headers
Set up Vue.js
Set up Vue Router
Create the Vue Components
Fetch the data

Each section will provide links to any necessary resources and give you a chance to pause and come back as needed.

Prerequisites

You’ll be best equipped for this tutorial if you already have a solid foundation in some web application concepts. You should understand how HTTP requests and responses and APIs work. You can check out Python & APIs: A Winning Combo for Reading Public Data to understand the details of using GraphQL APIs vs REST APIs.

Because you’ll use Django to build the back end for your blog, you’ll want to be familiar with starting a Django project and customizing the Django admin. If you haven’t used Django much before, you might also want to try building another Django-only project first. For a good introduction, check out Get Started with Django Part 1: Build a Portfolio App.

Because you’ll be using Vue on the front end, some experience with reactive JavaScript will also help. If you’ve only used a DOM manipulation paradigm with a framework like jQuery in the past, the Vue introduction is a good foundation.

Familiarity with JSON is also important because GraphQL queries are JSON-like and return data in JSON format. You can read about Working with JSON Data in Python for an introduction. You’ll also need to install Node.js to work on the front end later in this tutorial.

Step 1: Set Up the Django Blog

Before going too far, you’ll need a directory in which you can organize the code for your project. Start by creating one called dvg/, short for Django-Vue-GraphQL:

$ mkdir dvg/
$ cd dvg/

You’ll also be completely splitting up the front-end and back-end code, so it’s a good idea to start creating that separation right off the bat. Create a backend/ directory in your project directory:

Read the full article at https://realpython.com/python-django-blog/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #61: Scaling Data Science and Machine Learning Infrastructure Like Netflix

2021-05-21T12:00:00+00:00

Would you move your data science project from a laptop to the cloud? Would you also like to have snapshots of your project saved along the way so that you can go back in time or share the state of your project with another team member? This week on the show, we have Savin Goyal from Netflix. Savin is the technical lead for machine learning infrastructure at Netflix. He joins us to talk about Metaflow, an open-source tool to simplify building, managing, and scaling data science projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Build a Bulk File Rename Tool With Python and PyQt

2021-05-19T14:00:00+00:00

Say you need to rename multiple files in your personal folder using a specific naming pattern. Doing that manually can be time-consuming and error-prone. So, you’re thinking of automating the file renaming process by building your own bulk file rename tool using Python. If so, then this tutorial is for you.

In this tutorial, you’ll learn how to:

Create the GUI for a bulk file rename tool using Qt Designer and PyQt
Use PyQt threads to offload the file renaming process and prevent freezing GUIs
Use pathlib to manage system paths and rename files
Update the GUI state according to the renaming process

By completing the project in this tutorial, you’ll be able to apply a rich set of skills related to PyQt, Qt Designer, PyQt threads, and working with file system paths using Python’s pathlib.

You can download the final source code for the bulk file rename tool you’ll build in this tutorial by clicking the link below:

Get the Source Code: Click here to get the source code you’ll use to build a bulk file rename tool with Python in this tutorial.

Demo: Bulk File Rename Tool With Python and PyQt

In this tutorial, you’ll build a bulk file rename tool to automate the process of renaming multiple files in a given directory in your file system. To build this application, you’ll use Python’s pathlib to manage the file renaming process and PyQt to build the application’s graphical user interface (GUI).

Here’s how your bulk file rename tool will look and work once you get to the end of this tutorial:

Once you finish building the application, you’ll be able to rename multiple files in your file system, a common task when you’re organizing your personal files and folders. In this example, the application focuses on images and Python files, but you can add other file types as you go.

Project Overview

The project you’ll build in this tutorial consists of a GUI application that loads multiple files from a given directory and allows you to rename all those files in one go using a predefined filename prefix and consecutive numbers. In this section, you’ll take a first look at the problem and a possible solution. You’ll also figure out how to lay out the project.

Laying Out the Project

To build your bulk file rename tool, you’ll create a few modules and packages and organize them in a coherent Python application layout. Your project’s root directory will look like this:

./rprename_project/
│
├── rprename/
│   │
│   ├── ui/
│   │   ├── __init__.py
│   │   ├── window.py
│   │   └── window.ui
│   │
│   ├── __init__.py
│   ├── app.py
│   ├── rename.py
│   └── views.py
│
├── README.md
├── requirements.txt
└── rprenamer.py

Here, rprename_project/ is the project’s root directory, where you’ll create the following files:

README.md provides a general project description and instructions on installing and running the application. Having a README.md file for your project is considered a best practice in programming, especially if you’re planning to release it as an open source solution.
requirements.txt provides the list of external dependencies for the project.
rprenamer.py provides an entry-point script to run the application.

Then you have the rprename/ directory that will hold a Python package with the following modules:

__init__.py enables rprename/ as a Python package.
app.py provides the PyQt skeleton application.
rename.py provides the file renaming functionalities.
views.py provides the application’s GUI and related functionalities.

The ui/ subdirectory will provide a package to store GUI-related code. It’ll contain the following files and modules:

__init__.py enables ui/ as a Python package.
window.py contains the Python code for the application’s main window. You’ll see how to generate this file using pyuic5.
window.ui holds a Qt Designer file that contains the code for the application’s main window in XML format.

Go ahead and create this directory structure with all the files and modules except for window.ui and window.py. You’ll see how to create these two files with Qt Designer and pyuic5 later in this tutorial.

To download the project’s directory structure, click the link below:

Get the Source Code: Click here to get the source code you’ll use to build a bulk file rename tool with Python in this tutorial.

Read the full article at https://realpython.com/bulk-file-rename-tool-python/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Using the Python or Operator

2021-05-18T14:00:00+00:00

There are three Boolean operators in Python: and, or, and not. With them, you can test conditions and decide which execution path your programs will take. In this tutorial, you’ll take a deep dive into the Python or operator and how to use it.

By the end of this course, you’ll have learned:

How the Python or operator works
How to use the Python or operator in Boolean and non-Boolean contexts
What kind of programming problems you can solve by using or in Python
How to read and better understand other people’s code when they use some of the special features of the Python or operator

You’ll learn how to use the Python or operator by building some practical examples. Even if you don’t really use all the possibilities that the Python or operator offers, mastering it will allow you to write better code.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Embedded Python: Build a Game on the BBC micro:bit

2021-05-17T14:00:00+00:00

Writing code that runs in the terminal or in your web browser is good fun. Writing code that affects the real world, however, can be satisfying on a whole other level. Writing this sort of code is called embedded development, and Python is making it more accessible than ever!

In this tutorial, you’ll learn:

What embedded development is and why you would use Python to do it
What your hardware and software options are for running Python on an embedded system
When Python is a good fit for an embedded system and when it’s not
How to write a basic game on the BBC micro:bit with MicroPython

This tutorial contains code snippets that allow you to build a simple game on the BBC micro:bit. To access the full code and get a sneak preview on what you’ll be building, click the link below:

Get Sample Code: Click here to get the sample code you’ll use to learn about embedded development with Python in this tutorial.

What Is Embedded Development?

Embedded development is writing code for any device that isn’t a general-purpose computer. This definition is a little bit ambiguous, so some examples might help:

General-purpose computers include laptops, desktop PCs, smartphones, and so on.
Embedded systems include washing machines, digital machines, robots, and so on.

As a general rule of thumb, if you wouldn’t call something a computer, but it still has code running on it, then it’s probably an embedded system. The name comes from the idea of embedding a computer into a physical system to perform some task.

Embedded systems tend to be designed to do a single task, which is why we refer to regular computers as “general purpose”: they are designed to do more than one task.

In the same way that you need a computer to run regular code, to run embedded code, you need some kind of hardware. These pieces of hardware are usually referred to as development boards, and this tutorial will introduce you to a few designed to run Python.

Python for Embedded Development

One of the best things about learning Python is that it’s applicable in so many places. You can write code that runs anywhere, even on embedded systems. In this section, you’ll learn about the trade-offs that come with using Python for your embedded project and some things to be aware of when starting out.

Benefits of Using Python

The core benefit that Python brings when building an embedded system is development speed. Python has libraries available for most tasks, and this still mostly holds true for its embedded implementations. You can focus on building your system since many of the problems you’d encounter have been solved already.

Since Python is higher level than other common embedded languages, the code you’ll write will be more concise. This helps development speed, meaning you’ll write code faster, but it also helps keep your code understandable.

Python is memory managed. C++, a common choice for embedded development, is not. In C++, you are responsible for freeing up memory when you’re done with it, something that is very easy to forget, leading to your program running out of memory. Python does this for you.

Disadvantages of Using Python

While Python’s memory management is a big help, it does incur a minor speed and memory cost. The MicroPython docs have a good discussion on memory issues.

Another thing to consider is that the Python interpreter itself takes up space. With a compiled language, the size of your program depends just on your program, but Python programs need the interpreter that runs them. The Python interpreter also takes up RAM. On the micro:bit, you can’t write Bluetooth code with Python since there’s not enough room for Python and Bluetooth at the same time.

Since Python is interpreted, it can never be quite as fast as a compiled language. An interpreted language needs to decode each instruction before running it, but a compiled language can just run. In practice, though, this rarely matters as Python programs still run fast enough for most use cases.

Things to Watch Out for When New to Embedded Development

Modern computers have lots of memory to work with. When you’re programming them, you don’t have to worry too much about the size of lists you create or loading a whole file at once. Embedded systems, however, have limited memory. You have to be careful when writing your programs not to have too many things in memory at once.

Similarly, processor speeds on embedded systems are much slower than on desktop computers. The processor speed determines how quickly your code gets executed, so running a program on an embedded computer will take longer than running it on a desktop computer. It’s more important to think about the efficiency of embedded code—you don’t want it to take forever to run!

Perhaps the biggest change when programming embedded systems is power requirements. Laptops, phones and desktop computers either plug into the wall or have large batteries. Embedded systems often have tiny batteries and have to last for a really long time, sometimes even years. Every line of code that you run costs a little bit of battery life, and it all adds up.

Read the full article at https://realpython.com/embedded-python/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #60: Building a Platform Game With Arcade and Covering Python News Monthly

2021-05-14T12:00:00+00:00

Did you know the Python Software Foundation is hiring! With the recent support of three Visionary Sponsors, the PSF has been able to open positions for a developer-in-residence and a Python packaging project manager. Real Python now has a monthly Python news article. Frequent guest of the show, David Amos compiles and summarizes the biggest Python news from the past month.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Write Pythonic and Clean Code With namedtuple

2021-05-12T14:00:00+00:00

Python’s collections module provides a factory function called namedtuple(), which is specially designed to make your code more Pythonic when you’re working with tuples. With namedtuple(), you can create immutable sequence types that allow you to access their values using descriptive field names and the dot notation instead of unclear integer indices.

If you have some experience using Python, then you know that writing Pythonic code is a core skill for Python developers. In this tutorial, you’ll level up that skill using namedtuple.

In this tutorial, you’ll learn how to:

Create namedtuple classes using namedtuple()
Identify and take advantage of cool features of namedtuple
Use namedtuple instances to write Pythonic code
Decide whether to use a namedtuple or a similar data structure
Subclass a namedtuple to provide new features

To get the most out of this tutorial, you need to have a general understanding of Python’s philosophy related to writing Pythonic and readable code. You also need to know the basics of working with:

If you don’t have all the required knowledge before starting this tutorial, then that’s okay! You can stop and review the above resources as needed.

Free Bonus: Click here to get a Python Cheat Sheet and learn the basics of Python 3, like working with data types, dictionaries, lists, and Python functions.

Using `namedtuple` to Write Pythonic Code

Python’s namedtuple() is a factory function available in collections. It allows you to create tuple subclasses with named fields. You can access the values in a given named tuple using the dot notation and the field names, like in obj.attr.

Python’s namedtuple was created to improve code readability by providing a way to access values using descriptive field names instead of integer indices, which most of the time don’t provide any context on what the values are. This feature also makes the code cleaner and more maintainable.

In contrast, using indices to values in a regular tuple can be annoying, difficult to read, and error-prone. This is especially true if the tuple has a lot of fields and is constructed far away from where you’re using it.

Note: In this tutorial, you’ll find different terms used to refer to Python’s namedtuple, its factory function, and its instances.

To avoid confusion, here’s a summary of how each term is used throughout the tutorial:

Term	Meaning
`namedtuple()`	The factory function
`namedtuple`, `namedtuple` class	The tuple subclass returned by `namedtuple()`
`namedtuple` instance, named tuple	An instance of a specific `namedtuple` class

You’ll find these terms used with their corresponding meaning throughout the tutorial.

Besides this main feature of named tuples, you’ll find out that they:

Are immutable data structures
Have a consistent hash value
Can work as dictionary keys
Can be stored in sets
Have a helpful docstring based on the type and field names
Provide a helpful string representation that prints the tuple content in a name=value format
Support indexing
Provide additional methods and attributes, such as ._make(), _asdict(), ._fields, and so on
Are backward compatible with regular tuples
Have similar memory consumption to regular tuples

In general, you can use namedtuple instances wherever you need a tuple-like object. Named tuples have the advantage that they provide a way to access their values using field names and the dot notation. This will make your code more Pythonic.

With this brief introduction to namedtuple and its general features, you can dive deeper into creating and using them in your code.

Creating Tuple-Like Classes With `namedtuple()`

You use a namedtuple() to create an immutable and tuple-like data structure with field names. A popular example that you’ll find in tutorials about namedtuple is to create a class to represent a mathematical point.

Depending on the problem, you probably want to use an immutable data structure to represent a given point. Here’s how you can create a two-dimensional point using a regular tuple:

>>>

>>> # Create a 2D point as a tuple
>>> point = (2, 4)
>>> point
(2, 4)

>>> # Access coordinate x
>>> point[0]
2
>>> # Access coordinate y
>>> point[1]
4

>>> # Try to update a coordinate value
>>> point[0] = 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Here, you create an immutable two-dimensional point using a regular tuple. This code works: You have a point with two coordinates, and you can’t modify any of those coordinates. However, is this code readable? Can you tell up front what the 0 and 1 indices mean? To prevent these ambiguities, you can use a namedtuple like this:

>>>

>>> from collections import namedtuple

>>> # Create a namedtuple type, Point
>>> Point = namedtuple("Point", "x y")
>>> issubclass(Point, tuple)
True

>>> # Instantiate the new type
>>> point = Point(2, 4)
>>> point
Point(x=2, y=4)

>>> # Dot notation to access coordinates
>>> point.x
2
>>> point.y
4

>>> # Indexing to access coordinates
>>> point[0]
2
>>> point[1]
4

>>> # Named tuples are immutable
>>> point.x = 100
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: can't set attribute

Now you have a point with two appropriately named fields, x and y. Your point provides a user-friendly and descriptive string representation (Point(x=2, y=4)) by default. It allows you to access the coordinates using the dot notation, which is convenient, readable, and explicit. You can also use indices to access the value of each coordinate.

Note: It’s important to note that, while tuples and named tuples are immutable, the values they store don’t necessarily have to be immutable.

It’s totally legal to create a tuple or a named tuple that holds mutable values:

>>>

>>> from collections import namedtuple

>>> Person = namedtuple("Person", "name children")
>>> john = Person("John Doe", ["Timmy", "Jimmy"])
>>> john
Person(name='John Doe', children=['Timmy', 'Jimmy'])
>>> id(john.children)
139695902374144

>>> john.children.append("Tina")
>>> john
Person(name='John Doe', children=['Timmy', 'Jimmy', 'Tina'])
>>> id(john.children)
139695902374144

>>> hash(john)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

You can create named tuples that contain mutable objects. You can modify the mutable objects in the underlying tuple. However, this doesn’t mean that you’re modifying the tuple itself. The tuple will continue holding the same memory references.

Finally, tuples or named tuples with mutable values aren’t hashable, as you saw in the above example.

Read the full article at https://realpython.com/python-namedtuple/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Stacks and Queues: Selecting the Ideal Data Structure

2021-05-11T14:00:00+00:00

There are a variety of ways for storing and managing data in your program and the choice of the right data structure has an effect on the readability of your code, ease of writing, and performance. Python has a wide selection of built-in mechanisms that meet most of your data structure needs. This course introduces you to three types of data structures: stacks, queues, and priority queues.

There are multiple types and classes for all of these data structures and this course discusses them and provides information on how to choose the right one.

In this course you’ll learn about:

How stacks are defined with Last-In/First-Out (LIFO) semantics
How to use the collections.deque object
How concurrency will affect your choice
What are priority queues
Which data structure methods are thread safe
How to decide between all of implementations of these data structures

The course is the third part of an ongoing series, exploring how to find the right Data Structure for your projects. The first course is Dictionaries and Arrays: Selecting the Ideal Data Structure and the second course is Records and Sets: Selecting the Ideal Data Structure.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #59: Organizing and Restructuring DjangoCon Europe 2021

2021-05-07T12:00:00+00:00

Are you interested in learning more about Django? Would you like to meet other professionals and learn how they are using Django? DjangoCon Europe 2021 is virtual this year, and you can join in from anywhere in the world. This week on the show, we have Miguel Magalhães and David Vaz, two of the organizers of the conference.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Simplify Python GUI Development With PySimpleGUI

2021-05-04T14:00:00+00:00

Creating a simple graphical user interface (GUI) that works across multiple platforms can be complicated. But it doesn’t have to be that way. You can use Python and the PySimpleGUI package to create nice-looking user interfaces that you and your users will enjoy! PySimpleGUI is a new Python GUI library that has been gaining a lot of interest recently.

In this course, you’ll learn how to:

Install the PySimpleGUI package
Create basic user interface elements with PySimpleGUI
Create applications, such as a PySimpleGUI image viewer
Integrate PySimpleGUI with Matplotlib
Use computer vision in PySimpleGUI
Package your PySimpleGUI application for Windows

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #58: Podcast Rewind With Guest Highlights for 2020-2021

2021-04-30T12:00:00+00:00

This week's show is a bit different. We are taking a well-deserved short break, but we still wanted to share an episode with you. This rewind episode highlights clips from the many interviews over the past year or so of the show.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Python's map() Function: Transforming Iterables

2021-04-27T14:00:00+00:00

Python’s map() is a built-in function that allows you to process and transform all the items in an iterable without using an explicit for loop, a technique commonly known as mapping. map() is useful when you need to apply a transformation function to each item in an iterable and transform them into a new iterable. map() is one of the tools that support a functional programming style in Python.

In this course, you’ll learn:

How Python’s map() works
How to transform different types of Python iterables using map()
How to combine map() with other functional tools to perform more complex transformations
What tools you can use to replace map() and make your code more Pythonic

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #57: Taking the Next Step in Python Game Development

2021-04-23T12:00:00+00:00

Are you interested in creating video games but feel limited in what you can accomplish within Python? Is there a platform where you can take advantage of your Python skills and provide the benefits of a dedicated game engine? This week on the show, we have Paweł Fertyk. Paweł is a Real Python author and has been creating games as Miskatonic Studio for several years now.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learn Text Classification With Python and Keras

2021-04-20T14:00:00+00:00

Imagine you could know the mood of the people on the Internet. Maybe you are not interested in its entirety, but only if people are today happy on your favorite social media platform. After this course, you’ll be equipped to do this. While doing this, you will get a grasp of current advancements of (deep) neural networks and how they can be applied to text.

Reading the mood from text with machine learning is called sentiment analysis, and it is one of the prominent use cases in text classification. This falls into the very active research field of natural language processing (NLP).

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #56: OrderedDict vs dict and Object Oriented Programming in Python vs Java

2021-04-16T12:00:00+00:00

Are you looking for a bit of order when working with dictionaries in Python? Are you aware that the Python dict has changed over the last several versions and now keeps items in order? Could you learn more about object-oriented programming in Python by comparing it to another language? This week on the show, David Amos is back, and he's brought another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Start Managing Multiple Python Versions With pyenv

2021-04-13T14:00:00+00:00

Have you ever wanted to contribute to a project that supports multiple versions of Python but aren’t sure how you would easily test all the versions? Are you ever curious about the latest and greatest versions of Python? Maybe you’d like to try out these new features, but you don’t want to worry about messing up your development environment. Luckily, managing multiple versions of Python doesn’t have to be confusing if you use pyenv.

This course will provide you with a great overview of how to maximize your time spent working on projects and minimize the time spent in headaches trying to use the right version of Python.

In this course, you’ll learn how to:

Install multiple versions of Python
Install the latest development version of Python
Switch between the installed versions
Use virtual environments with pyenv
Activate different Python versions and virtual environments automatically

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #55: Getting Started With Refactoring Your Python Code

2021-04-09T12:00:00+00:00

Do you think it's time to refactor your Python code? What should you think about before starting this task? This week on the show, we have Brendan Maginnis and Nick Thapen from Sourcery. Sourcery is an automated refactoring tool that integrates into your IDE and suggests improvements to your code.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Real Python

Using Pandas to Make a Gradebook in Python

Python Practice Problems: Parsing CSV Files

Python CSV Parsing: Football Scores

Problem Description

The Real Python Podcast – Episode #64: Detecting Deforestation With Python & Using GraphQL With Django and Vue

Python's filter(): Extract Values From Iterables

Coding With Functional Style in Python

Understanding the Filtering Problem

Getting Started With Python’s filter()

Python Basics: Setting Up Python

Python Community Interview With Sebastián Ramírez

The Real Python Podcast – Episode #63: Create Web Applications Using Only Python With Anvil

Context Managers and Python's with Statement

Managing Resources in Python

The try … finally Approach

Explore Your Dataset With Pandas

Python News: What's New From May 2021?

Microsoft Becomes the Third PSF Visionary Sponsor

Pallets Releases New Major Versions of All Core Projects

The Real Python Podcast – Episode #62: Selecting the Ideal Data Structure & Unravelling Python's "pass" and "with"

Visualizing Data in Python Using plt.scatter()

Creating Scatter Plots

Getting Started With plt.scatter()

Comparing plt.scatter() and plt.plot()

How to Set Up a Django Project

Build a Blog Using Django, Vue, and GraphQL

Demo: A Django Blog Admin, a GraphQL API, and a Vue Front End

Project Overview

Prerequisites

Step 1: Set Up the Django Blog

The Real Python Podcast – Episode #61: Scaling Data Science and Machine Learning Infrastructure Like Netflix

Build a Bulk File Rename Tool With Python and PyQt

Demo: Bulk File Rename Tool With Python and PyQt

Project Overview

Laying Out the Project

Using the Python or Operator

Embedded Python: Build a Game on the BBC micro:bit

What Is Embedded Development?

Python for Embedded Development

Benefits of Using Python

Disadvantages of Using Python

Things to Watch Out for When New to Embedded Development

The Real Python Podcast – Episode #60: Building a Platform Game With Arcade and Covering Python News Monthly

Write Pythonic and Clean Code With namedtuple

Using namedtuple to Write Pythonic Code

Creating Tuple-Like Classes With namedtuple()

Stacks and Queues: Selecting the Ideal Data Structure

The Real Python Podcast – Episode #59: Organizing and Restructuring DjangoCon Europe 2021

Simplify Python GUI Development With PySimpleGUI

The Real Python Podcast – Episode #58: Podcast Rewind With Guest Highlights for 2020-2021

Python's map() Function: Transforming Iterables

The Real Python Podcast – Episode #57: Taking the Next Step in Python Game Development

Learn Text Classification With Python and Keras

The Real Python Podcast – Episode #56: OrderedDict vs dict and Object Oriented Programming in Python vs Java

Start Managing Multiple Python Versions With pyenv

The Real Python Podcast – Episode #55: Getting Started With Refactoring Your Python Code

Getting Started With Python’s `filter()`

The `try` … `finally` Approach

Getting Started With `plt.scatter()`

Comparing `plt.scatter()` and `plt.plot()`

Using `namedtuple` to Write Pythonic Code

Creating Tuple-Like Classes With `namedtuple()`