Real Python

The Real Python Podcast – Episode #98: Drawing Fractals With Python and Working With a Weather API

2022-02-18T12:00:00+00:00

Have you been wanting to explore fractals and complex numbers in Python? Would you like to practice working with APIs in Python through a new project? This week on the show, Christopher Trudeau is here, and he's taking on the task of curating new issues of PyCoder's Weekly going forward. He'll be joining me as a cohost every other week and bringing a fresh 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 ]

Providing Multiple Constructors in Your Python Classes

2022-02-16T14:00:00+00:00

Sometimes you need to write a Python class that provides multiple ways to construct objects. In other words, you want a class that implements multiple constructors. This kind of class comes in handy when you need to create instances using different types or numbers of arguments. Having the tools to provide multiple constructors will help you write flexible classes that can adapt to changing needs.

In Python, there are several techniques and tools that you can use to construct classes, including simulating multiple constructors through optional arguments, customizing instance creation via class methods, and doing special dispatch with decorators. If you want to learn about these techniques and tools, then this tutorial is for you.

In this tutorial, you’ll learn how to:

Use optional arguments and type checking to simulate multiple constructors
Write multiple constructors using the built-in @classmethod decorator
Overload your class constructors using the @singledispatchmethod decorator

You’ll also get a peek under the hood at how Python internally constructs instances of a regular class and how some standard-library classes provide multiple constructors.

To get the most out of this tutorial, you should have basic knowledge of object-oriented programming and understand how to define class methods with @classmethod. You should also have experience working with decorators in Python.

Free Bonus: Click here to get access to a free Python OOP Cheat Sheet that points you to the best tutorials, videos, and books to learn more about Object-Oriented Programming with Python.

Instantiating Classes in Python

Python supports object-oriented programming with classes that are straightforward to create and use. Python classes offer powerful features that can help you write better software. Classes are like blueprints for objects, also known as instances. In the same way that you can build several houses from a single blueprint, you can build several instances from a class.

To define a class in Python, you need to use the class keyword followed by the class name:

>>>

>>> # Define a Person class
>>> class Person:
...     def __init__(self, name):
...         self.name = name
...

Python has a rich set of special methods that you can use in your classes. Python implicitly calls special methods to automatically execute a wide variety of operations on instances. There are special methods to make your objects iterable, provide a suitable string representation for your objects, initialize instance attributes, and a lot more.

A pretty common special method is .__init__(). This method provides what’s known as the instance initializer in Python. This method’s job is to initialize instance attributes with appropriate values when you instantiate a given class.

In Person, the .__init__() method’s first argument is called self. This argument holds the current object or instance, which is passed implicitly in the method call. This argument is common to every instance method in Python. The second argument to .__init__() is called name and will hold the person’s name as a string.

Note: Using self to name the current object is a pretty strong convention in Python but not a requirement. However, using another name will raise some eyebrows among your fellow Python developers.

Once you’ve defined a class, you can start instantiating it. In other words, you can start creating objects of that class. To do this, you’ll use a familiar syntax. Just call the class using a pair of parentheses (()), which is the same syntax that you use to call any Python function:

>>>

>>> # Instantiating Person
>>> john = Person("John Doe")
>>> john.name
'John Doe'

In Python, the class name provides what other languages, such as C++ and Java, call the class constructor. Calling a class, like you did with Person, triggers Python’s class instantiation process, which internally runs in two steps:

Create a new instance of the target class.
Initialize the instance with suitable instance attribute values.

To continue with the above example, the value that you pass as an argument to Person is internally passed to .__init__() and then assigned to the instance attribute .name. This way, you initialize your person instance, john, with valid data, which you can confirm by accessing .name. Success! John Doe is indeed his name.

Note: When you call the class to create a new instance, you need to provide as many arguments as .__init__() requires so that this method can initialize all the instance attributes that demand an initial value.

Now that you understand the object initialization mechanism, you’re ready to learn what Python does before it gets to this point in the instantiation process. It’s time to dig into another special method, called .__new__(). This method takes care of creating new instances in Python.

Note: The .__new__() special method is often called a class constructor in Python. However, its job is actually to create new objects from the class blueprint, so you can more accurately call it an instance creator or object creator.

The .__new__() special method takes the underlying class as its first argument and returns a new object. This object is typically an instance of the input class, but in some cases, it can be an instance of a different class.

If the object that .__new__() returns is an instance of the current class, then this instance is immediately passed to .__init__() for initialization purposes. These two steps run when you call the class.

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

[ 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 any(): Powered Up Boolean Function

2022-02-15T14:00:00+00:00

As a Python programmer, you’ll frequently deal with Booleans and conditional statements—sometimes very complex ones. In those situations, you may need to rely on tools that can simplify logic and consolidate information. Fortunately, any() in Python is such a tool. It looks through the elements in an iterable and returns a single value indicating whether any element is true in a Boolean context, or truthy.

In this course, you’ll learn how to:

Use any() and not any()
Elimate long or chains
Use any() with list comprehensions
Evalute values that aren’t explicitly True or False
Distinguish between any() and or
Use short-circuiting

[ 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 zipfile: Manipulate Your ZIP Files Efficiently

2022-02-14T14:00:00+00:00

Python’s zipfile is a standard library module intended to manipulate ZIP files. This file format is a widely adopted industry standard when it comes to archiving and compressing digital data. You can use it to package together several related files. It also allows you to reduce the size of your files and save disk space. Most importantly, it facilitates data exchange over computer networks.

Knowing how to create, read, write, populate, extract, and list ZIP files using the zipfile module is a useful skill to have as a Python developer or a DevOps engineer.

In this tutorial, you’ll learn how to:

Read, write, and extract files from ZIP files with Python’s zipfile
Read metadata about the content of ZIP files using zipfile
Use zipfile to manipulate member files in existing ZIP files
Create new ZIP files to archive and compress files

If you commonly deal with ZIP files, then this knowledge can help to streamline your workflow to process your files confidently.

To get the most out of this tutorial, you should know the basics of working with files, using the with statement, handling file system paths with pathlib, and working with classes and object-oriented programming.

To get the files and archives that you’ll use to code the examples in this tutorial, click the link below:

Get Materials: Click here to get a copy of the files and archives that you’ll use to run the examples in this zipfile tutorial.

Getting Started With ZIP Files

ZIP files are a well-known and popular tool in today’s digital world. These files are fairly popular and widely used for cross-platform data exchange over computer networks, notably the Internet.

You can use ZIP files for bundling regular files together into a single archive, compressing your data to save some disk space, distributing your digital products, and more. In this tutorial, you’ll learn how to manipulate ZIP files using Python’s zipfile module.

Because the terminology around ZIP files can be confusing at times, this tutorial will stick to the following conventions regarding terminology:

Term	Meaning
ZIP file, ZIP archive, or archive	A physical file that uses the ZIP file format
File	A regular computer file
Member file	A file that is part of an existing ZIP file

Having these terms clear in your mind will help you avoid confusion while you read through the upcoming sections. Now you’re ready to continue learning how to manipulate ZIP files efficiently in your Python code!

What Is a ZIP File?

You’ve probably already encountered and worked with ZIP files. Yes, those with the .zip file extension are everywhere! ZIP files, also known as ZIP archives, are files that use the ZIP file format.

PKWARE is the company that created and first implemented this file format. The company put together and maintains the current format specification, which is publicly available and allows the creation of products, programs, and processes that read and write files using the ZIP file format.

The ZIP file format is a cross-platform, interoperable file storage and transfer format. It combines lossless data compression, file management, and data encryption.

Data compression isn’t a requirement for an archive to be considered a ZIP file. So you can have compressed or uncompressed member files in your ZIP archives. The ZIP file format supports several compression algorithms, though Deflate is the most common. The format also supports information integrity checks with CRC32.

Even though there are other similar archiving formats, such as RAR and TAR files, the ZIP file format has quickly become a common standard for efficient data storage and for data exchange over computer networks.

ZIP files are everywhere. For example, office suites such as Microsoft Office and Libre Office rely on the ZIP file format as their document container file. This means that .docx, .xlsx, .pptx, .odt, .ods, .odp files are actually ZIP archives containing several files and folders that make up each document. Other common files that use the ZIP format include .jar, .war, and .epub files.

You may be familiar with GitHub, which provides web hosting for software development and version control using Git. GitHub uses ZIP files to package software projects when you download them to your local computer. For example, you can download the exercise solutions for Python Basics: A Practical Introduction to Python 3 book in a ZIP file, or you can download any other project of your choice.

ZIP files allow you to aggregate, compress, and encrypt files into a single interoperable and portable container. You can stream ZIP files, split them into segments, make them self-extracting, and more.

Why Use ZIP Files?

Knowing how to create, read, write, and extract ZIP files can be a useful skill for developers and professionals who work with computers and digital information. Among other benefits, ZIP files allow you to:

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

[ 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 #97: Improving Your Django and Python Developer Experience

2022-02-11T12:00:00+00:00

How often have you thought about your Developer Experience (DX)? How do you improve your workflow, find documentation, and simplify code formatting? This week on the show, Adam Johnson is here to talk about his new book, "Boost Your Django DX."

[ 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 all(): Check Your Iterables for Truthiness

2022-02-09T14:00:00+00:00

When programming, you’ll often need to check if all the items in an iterable are truthy. Coding this functionality repeatedly can be annoying and inefficient. Luckily, Python provides the built-in all() function to solve this problem. This function takes an iterable and checks all its items for truth value, which is handy for finding out if those items have a given property or meet a particular condition.

Python’s all() is a powerful tool that can help you write clean, readable, and efficient code in Python.

In this tutorial, you’ll learn how to:

Check if all the items in an iterable are truthy by using all()
Use all() with different iterable types
Combine all() with comprehensions and generator expressions
Distinguish between all() and the Boolean and operator

To complement this knowledge, you’ll code several examples that showcase exciting use cases of all() and highlight the many ways to use this function in Python programming.

To understand the topics in this tutorial, you should have basic knowledge of several Python concepts, such as iterable data structures, Boolean types, expressions, operators, list comprehensions, and generator expressions.

Free PDF Download: Python 3 Cheat Sheet

Evaluating the Truth Value of Items in Iterables

A pretty common problem in programming is determining if all the items in a list or array are truthy or not. For example, you may have the following list of conditions:

5 > 2
1 == 1
42 < 50

To figure out if these conditions are true, you need to iterate over them and test every condition for truthiness. In this example, you have that 5 > 2 is true, 1 == 1 is true, and 42 < 50 is also true. As a result, you can say that all these conditions are true. If at least one of the conditions were false, then you would say that not all the conditions are true.

Note that as soon as you find a falsy condition, you can stop evaluating conditions because, in that case, you already know the final result: not all are true.

To solve this problem by writing custom Python code, you can use a for loop to iterate over each condition and evaluate it for truthiness. Your loop will iterate until it finds a falsy item, at which point it’ll stop because you already have a result:

>>>

>>> def all_true(iterable):
...     for item in iterable:
...         if not item:
...             return False
...     return True
...

This function takes an iterable as an argument. The loop iterates over the input argument while the conditional if statement checks if any item is falsy using the not operator. If an item is falsy, then the function immediately returns False, signaling that not all the items are true. Otherwise, it returns True.

This function is quite generic. It takes an iterable, which means you can pass in a list, tuple, string, dictionary, or any other iterable data structure. To check if the current item is true or false, all_true() uses the not operator to invert the truth value of its operand. In other words, it returns True if its operand evaluates to false and vice versa.

Python’s Boolean operators can evaluate the truth value of expressions and objects, which guarantees that your function can take iterables containing objects, expressions, or both. For example, if you pass in an iterable of Boolean expressions, then not just evaluates the expression and negates the result.

Here’s all_true() in action:

>>>

>>> bool_exps = [
...     5 > 2,
...     1 == 1,
...     42 < 50,
... ]
>>> all_true(bool_exps)
True

Because all the expressions in the input iterable are true, not negates the result, and the if code block never runs. In that case, all_true() returns True.

Something similar happens when the input iterable holds Python objects and non-Boolean expressions:

>>>

>>> objects = ["Hello!", 42, {}]
>>> all_true(objects)
False

>>> general_expressions = [
...     5 ** 2,
...     42 - 3,
...     int("42")
... ]
>>> all_true(general_expressions)
True

>>> empty = []
>>> all_true(empty)
True

In the first example, the input list contains regular Python objects, including a string, a number, and a dictionary. In this case, all_true() returns False because the dictionary is empty and evaluates to false in Python.

To perform truth value testing on objects, Python has an internal set of rules for objects that evaluate as false:

Inherently negative constants, like None and False
Numeric types with a zero value, like 0, 0.0, 0j, Decimal("0"), and Fraction(0, 1)
Empty sequences and collections, like "", (), [], {}, set(), and range(0)
Objects that implement .__bool__() with a return value of False or .__len__() with a return value of 0

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

[ 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 ]

Defining Python Functions With Optional Arguments

2022-02-08T14:00:00+00:00

Defining your own functions is an essential skill for writing clean and effective code. In this tutorial, you’ll explore the techniques you have available for defining Python functions that take optional arguments. When you master Python optional arguments, you’ll be able to define functions that are more powerful and more flexible.

In this course, you’ll learn how to:

Distinguish between parameters and arguments
Define functions with optional arguments and default parameter values
Define functions using args and kwargs
Deal with error messages about optional arguments

[ 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 January 2022?

2022-02-07T14:00:00+00:00

In January 2022, the code formatter Black saw its first non-beta release and published a new stability policy. IPython, the powerful interactive Python shell, marked the release of version 8.0, its first major version release in three years. Additionally, PEP 665, aimed at making reproducible installs easier by specifying a format for lock files, was rejected. Last but not least, a fifteen-year-old memory leak bug in Python was fixed.

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

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.

Black No Longer Beta

The developers of Black, an opinionated code formatter, are now confident enough to call the latest release stable. This announcement brings Black out of beta for the first time:

Code formatting can be the source of a surprising amount of conflict among developers. This is why code formatters, or linters, help enforce style conventions to maintain consistency across a whole codebase. Linters suggest changes, while code formatters rewrite your code:

This makes your codebase more consistent, helps catch errors early, and makes code easier to scan.

YAPF is an example of a formatter. It comes with the PEP 8 style guide as a default, but it’s not strongly opinionated, giving you a lot of control over its configuration.

Black goes further: it comes with a PEP 8 compliant style, but on the whole, it’s not configurable. The idea behind disallowing configuration is that you free up your brain to focus on the actual code by relinquishing control over style. Many believe this restriction gives them much more freedom to be creative coders. But of course, not everyone likes to give up this control!

One crucial feature of opinionated formatters like Black is that they make your diffs much more informative. If you’ve ever committed a cleanup or formatting commit to your version control system, you may have inadvertently polluted your diff.

Read the full article at https://realpython.com/python-news-january-2022/ »

[ 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 #96: Manipulating and Analyzing Audio in Python

2022-02-04T12:00:00+00:00

Would you like to experiment with analyzing or manipulating audio with Python? This week on the show, we have Braden Riggs from DolbyIO to discuss extracting audio features and Python libraries for reshaping audio. Braden shares techniques from his recent talk at PyData Global, "Unlocking More From Your Audio Data!"

[ 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 Python's pip to Manage Your Projects' Dependencies

2022-02-02T14:00:00+00:00

The standard package manager for Python is pip. It allows you to install and manage packages that aren’t part of the Python standard library. If you’re looking for an introduction to pip, then you’ve come to the right place!

In this tutorial, you’ll learn how to:

Set up pip in your working environment
Fix common errors related to working with pip
Install and uninstall packages with pip
Manage projects’ dependencies using requirements files

You can do a lot with pip, but the Python community is very active and has created some neat alternatives to pip. You’ll learn about those later in this tutorial.

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.

Getting Started With `pip`

So, what exactly does pip do? pip is a package manager for Python. That means it’s a tool that allows you to install and manage libraries and dependencies that aren’t distributed as part of the standard library. The name pip was introduced by Ian Bicking in 2008:

I’ve finished renaming pyinstall to its new name: pip. The name pip is [an] acronym and declaration: pip installs packages. (Source)

Package management is so important that Python’s installers have included pip since versions 3.4 and 2.7.9, for Python 3 and Python 2, respectively. Many Python projects use pip, which makes it an essential tool for every Pythonista.

The concept of a package manager might be familiar to you if you’re coming from another programming language. JavaScript uses npm for package management, Ruby uses gem, and the .NET platform uses NuGet. In Python, pip has become the standard package manager.

Finding `pip` on Your System

The Python 3 installer gives you the option to install pip when installing Python on your system. In fact, the option to install pip with Python is checked by default, so pip should be ready for you to use after installing Python.

Note: On some Linux (Unix) systems like Ubuntu, pip comes in a separate package called python3-pip, which you need to install with sudo apt install python3-pip. It’s not installed by default with the interpreter.

You can verify that pip is available by looking for the pip3 executable on your system. Select your operating system below and use your platform-specific command accordingly:

C:\> where pip3

The where command on Windows will show you where you can find the executable of pip3. If Windows can’t find an executable named pip3, then you can also try looking for pip without the three (3) at the end.

$ which pip3

The which command on Linux systems and macOS shows you where the pip3 binary file is located.

On Windows and Unix systems, pip3 may be found in more than one location. This can happen when you have multiple Python versions installed. If you can’t find pip in any location on your system, then you may consider reinstalling pip.

Instead of running your system pip directly, you can also run it as a Python module. In the next section, you’ll learn how.

Running `pip` as a Module

When you run your system pip directly, the command itself doesn’t reveal which Python version pip belongs to. This unfortunately means that you could use pip to install a package into the site-packages of an old Python version without noticing. To prevent this from happening, you can run pip as a Python module:

$ python3 -m pip

Notice that you use python3 -m to run pip. The -m switch tells Python to run a module as an executable of the python3 interpreter. This way, you can ensure that your system default Python 3 version runs the pip command. If you want to learn more about this way of running pip, then you can read Brett Cannon’s insightful article about the advantages of using python3 -m pip.

Sometimes you may want to be more explicit and limit packages to a specific project. In situations like this, you should run pip inside a virtual environment.

Using `pip` in a Python Virtual Environment

To avoid installing packages directly into your system Python installation, you can use a virtual environment. A virtual environment provides an isolated Python interpreter for your project. Any packages that you use inside this environment will be independent of your system interpreter. This means that you can keep your project’s dependencies separate from other projects and the system at large.

Read the full article at https://realpython.com/what-is-pip/ »

[ 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 len() Function

2022-02-01T14:00:00+00:00

In many situations, you’ll need to find the number of items stored in a data structure. Python’s built-in function len() is the tool that will help you with this task.

There are some cases in which the use of len() is straightforward. However, there are other times when you’ll need to understand how this function works in more detail and how to apply it to different data types.

In this course, you’ll learn how to:

Find the length of built-in data types using len()
Use len() with third-party data types
Provide support for len() with user-defined classes

[ 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 ]

Draw the Mandelbrot Set in Python

2022-01-31T14:00:00+00:00

This tutorial will guide you through a fun project involving complex numbers in Python. You’re going to learn about fractals and create some truly stunning art by drawing the Mandelbrot set using Python’s Matplotlib and Pillow libraries. Along the way, you’ll learn how this famous fractal was discovered, what it represents, and how it relates to other fractals.

Knowing about object-oriented programming principles and recursion will enable you to take full advantage of Python’s expressive syntax to write clean code that reads almost like math formulas. To understand the algorithmic details of making fractals, you should also be comfortable with complex numbers, logarithms, set theory, and iterated functions. But don’t let these prerequisites scare you away, as you’ll be able to follow along and produce the art anyway!

In this tutorial, you’ll learn how to:

Apply complex numbers to a practical problem
Find members of the Mandelbrot and Julia sets
Draw these sets as fractals using Matplotlib and Pillow
Make a colorful artistic representation of the fractals

To download the source code used in this tutorial, click the link below:

Get Source Code: Click here to get the source code you’ll use to draw the Mandelbrot set.

Understanding the Mandelbrot Set

Before you try to draw the fractal, it’ll help to understand what the corresponding Mandelbrot set represents and how to determine its members. If you’re already familiar with the underlying theory, then feel free to skip ahead to the plotting section below.

The Icon of Fractal Geometry

Even if the name is new to you, you might have seen some mesmerizing visualizations of the Mandelbrot set before. It’s a set of complex numbers, whose boundary forms a distinctive and intricate pattern when depicted on the complex plane. That pattern became arguably the most famous fractal, giving birth to fractal geometry in the late 20th century:

The discovery of the Mandelbrot set was possible thanks to technological advancement. It’s attributed to a mathematician named Benoît Mandelbrot. He worked at IBM and had access to a computer capable of what was, at the time, demanding number crunching. Today, you can explore fractals in the comfort of your home, using nothing more than Python!

Fractals are infinitely repeating patterns on different scales. While philosophers have argued for centuries about the existence of infinity, fractals do have an analogy in the real world. It’s a fairly common phenomenon occurring in nature. For example, this Romanesco cauliflower is finite but has a self-similar structure because each part of the vegetable looks like the whole, only smaller:

Self-similarity can often be defined mathematically with recursion. The Mandelbrot set isn’t perfectly self-similar as it contains slightly different copies of itself at smaller scales. Nevertheless, it can still be described by a recursive function in the complex domain.

The Boundary of Iterative Stability

Formally, the Mandelbrot set is the set of complex numbers, c, for which an infinite sequence of numbers, z₀, z₁, …, z_n, …, remains bounded. In other words, there is a limit that the magnitude of each complex number in that sequence never exceeds. The Mandelbrot sequence is given by the following recursive formula:

In plain English, to decide whether some complex number, c, belongs to the Mandelbrot set, you must feed that number to the formula above. From now on, the number c will remain constant as you iterate the sequence. The first element of the sequence, z₀, is always equal to zero. To calculate the next element, z_n+1, you’ll keep squaring the last element, z_n, and adding your initial number, c, in a feedback loop.

By observing how the resulting sequence of numbers behaves, you’ll be able to classify your complex number, c, as either a Mandelbrot set member or not. The sequence is infinite, but you must stop calculating its elements at some point. Making that choice is somewhat arbitrary and depends on your accepted level of confidence, as more elements will provide a more accurate ruling on c.

Note: The entire Mandelbrot set fits in a circle with a radius of two when depicted on the complex plane. This is a handy fact that’ll let you skip many unnecessary calculations for points that certainly don’t belong to the set.

With complex numbers, you can imagine this iterative process visually in two dimensions, but you can go ahead and consider only real numbers for the sake of simplicity now. If you were to implement the above equation in Python, then it could look something like this:

>>>

>>> def z(n, c):
...     if n == 0:
...         return 0
...     else:
...         return z(n - 1, c) ** 2 + c

Your z() function returns the nth element of the sequence, which is why it expects an element’s index, n, as the first argument. The second argument, c, is a fixed number that you’re testing. This function would keep calling itself infinitely due to recursion. However, to break that chain of recursive calls, a condition checks for the base case with an immediately known solution—zero.

Try using your new function to find the first ten elements of the sequence for c = 1, and see what happens:

Read the full article at https://realpython.com/mandelbrot-set-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 #95: What Is a JIT and How Can Pyjion Speed Up Your Python?

2022-01-28T12:00:00+00:00

How can you can speed up Python? Have you thought of using a JIT (Just-In-Time Compiler)? This week on the show, we have Real Python author and previous guest Anthony Shaw to talk about his project Pyjion, a drop-in JIT compiler for CPython 3.10.

[ 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 ]

Raining Outside? Build a Weather CLI App With Python

2022-01-26T14:00:00+00:00

You’re stuck inside because of torrential rains—again! You wonder what the weather’s like in that faraway city where your friends from the Real Python community live. You’d rather stick around in your command-line interface (CLI) than look it up in your browser. If that sounds like a task you’d want to tackle by building a command-line weather app using only the Python standard library, then this tutorial is for you.

In this tutorial, you’ll learn how to:

Build a functional weather lookup tool using only Python standard library modules
Build a Python CLI app using argparse
Use configparser to handle API secrets
Make API calls from your Python script
Create visually attractive CLI output using ANSI escape codes, emojis, f-strings, and Python’s string mini-language

Looking out the window confirms your decision. With that rain, there’s no way to frolic in the meadows today. Time to write a Python weather app and dream of distant places right from your CLI! You might even discover a couple of surprising city names along the way.

Get Source Code: Click here to get the source code you’ll use to build your weather app.

Demo

While you wait for a rainbow to appear outside your window, you’ll add your own colors to your weather app. For that, you’ll use some formatting tricks that’ll make the CLI output snazzier than plain text:

If you like the look of this command-line app and want to train your Python coding skills while using the standard library, then you’ve come to the right place!

Note: This app was developed on macOS for the Zsh shell. Your mileage with some of the color display and emojis may vary depending on your setup. On Windows, PowerShell displays the formatting reasonably well, and if you’re on a newer version of the operating system, you should see good results with the defaults in Windows Terminal.

If you’d prefer another color scheme or want to use different emojis for your own app, you’ll be able to customize it while working along with this tutorial.

Project Overview

Before you start to write any code, it’s often a good idea to think about the specifications of the program you’re planning to build. First, take out a pen and paper and jot down your ideas for what a perfect weather app would look like. Once you’ve noted your ideas, you can click on the heading below to read what specifications you’ll consider when working through this tutorial:

The weather app you’ll build in this tutorial will:

Take a city name as required input
Take an optional flag to display the output in Fahrenheit instead of Celsius, if desired
Call an online weather API to fetch the weather data
Display the city name, the current weather conditions, and the current temperature
Format the output visually using colors, spacing, and emojis

With these quick notes, you have a rough plan of what you’ll build, and you’ve defined the scope of what the app will be able to do.

If you have different or additional features in mind, then keep your notes around and implement them on top of your weather app once you’ve finished building this initial version.

Note: Writing great command-line interfaces can be challenging. You want your app to be user-friendly and still provide all the functionality you need. Using higher-level libraries might make it easier for you to build out your applications.

In this tutorial, you’ll work with Python’s built-in argparse module, which assists you in creating user-friendly CLI apps, for example by providing a useful --help option out of the box.

You’ll get the current weather data by city name from different locations around the world, using the weather API from OpenWeather. This application programming interface (API) is free to use, with a generous quota of API calls. However, you’ll need to create a personal API key to make requests, which you’ll do in just a moment.

Before you start digging in, take another look at the expected prerequisites so that you know where you can brush up on your skills in case you get stuck somewhere along the way.

Prerequisites

To complete this tutorial, you should be comfortable with the following concepts:

You’ll also need an API key for the weather API from OpenWeather, and you’ll learn how to get access to one in the upcoming section.

If you don’t have all of the prerequisite knowledge before starting this tutorial, that’s okay! In fact, you might learn more by going ahead and getting started. You can always stop and review the resources linked here if you get stuck.

Step 1: Get Access to a Suitable Weather API

Read the full article at https://realpython.com/build-a-python-weather-app-cli/ »

[ 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 ]

Looping With Python enumerate()

2022-01-25T14:00:00+00:00

In Python, a for loop is usually written as a loop over an iterable object. This means that you don’t need a counting variable to access items in the iterable. Sometimes, though, you do want to have a variable that changes on each loop iteration. Rather than creating and incrementing a variable yourself, you can use Python’s enumerate() to get a counter and the value from the iterable at the same time!

In this course, you’ll see how to:

Use enumerate() to get a counter in a loop
Apply enumerate() to display item counts
Implement your own equivalent function to enumerate()
Unpack values returned by enumerate()

[ 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 ]

Modulo String Formatting in Python

2022-01-24T14:00:00+00:00

If you’re writing modern Python code with Python 3, you’ll probably want to format your strings with Python f-strings. However, if you’re working with older Python codebases, you’re likely to encounter the string modulo operator for string formatting.

If you’re reading or writing Python 2 code, it’ll help if you’re familiar with this technique. Because the syntax still works in Python 3, you might even see developers use it in modern Python codebases.

In this tutorial, you’ll learn how to:

Use the modulo operator (%) for string formatting
Convert values into specific types before inserting them into your string
Specify the horizontal space a formatted value occupies
Fine-tune the display using conversion flags
Specify values using dictionary mapping instead of tuples

If you’re acquainted with the printf() family of functions of C, Perl, or Java, then you’ll see that these don’t exist in Python. However, there’s quite a bit of similarity between printf() and the string modulo operator, so if you’re familiar with printf(), then a lot of the following will feel familiar.

On the other hand, if you aren’t familiar with printf(), don’t worry! You don’t need any prior knowledge of printf() to master modulo string formatting in Python.

Free Bonus: Click here to get our free Python Cheat Sheet that shows you the basics of Python 3, like working with data types, dictionaries, lists, and Python functions.

Use the Modulo Operator for String Formatting in Python

You’ve probably used the modulo operator (%) before with numbers, in which case it computes the remainder from a division:

>>>

>>> 11 % 3
2

With string operands, the modulo operator has an entirely different function: string formatting.

Note: These two operations aren’t very much alike. They only share the same name because they are represented by the same symbol (%).

Here’s what the syntax of the string modulo operator looks like:

<format_string> % <values>

On the left side of the % operator, <format_string> is a string containing one or more conversion specifiers. The <values> on the right side get inserted into <format_string> in place of the conversion specifiers. The resulting formatted string is the value of the expression.

Get started with an example where you call print() to display a formatted string using the string modulo operator:

>>>

>>> print("%d %s cost $%.2f" % (6, "bananas", 1.74))
6 bananas cost $1.74

In addition to representing the string modulo operation itself, the % character also denotes the beginning of a conversion specifier in the format string—in this case, there are three: %d, %s, and %.2f.

In the output, Python converted each item from the tuple of values to a string value and inserted it into the format string in place of the corresponding conversion specifier:

The first item in the tuple is 6, a numeric value that replaces %d in the format string.
The next item is the string value "bananas", which replaces %s.
The last item is the float value 1.74, which replaces %.2f.

The resulting string is 6 bananas cost $1.74, as demonstrated in the following diagram:

If there are multiple values to insert, then they must be enclosed in a tuple, as illustrated above. If there’s only one value, then you can write it by itself without the surrounding parentheses:

>>>

>>> print("Hello, my name is %s." % "Graham")
Hello, my name is Graham.

Notice also that string modulo operation isn’t only for printing. You can also format values and assign them to another string variable:

Read the full article at https://realpython.com/python-modulo-string-formatting/ »

[ 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 #94: Designing for Users and Building a Social Network With Django

2022-01-21T12:00:00+00:00

Are you looking for a project to practice your Django skills? Designing the fundamental interactions of a social network is an instructive way to explore models and relationships while learning advanced Django skills. This week on the show, we talk with previous guest Martin Breuss about his new four-part series, "Build a Social Network With Django".

[ 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 Dice-Rolling Application With Python

2022-01-19T14:00:00+00:00

Building small projects, like a text-based user interface (TUI) dice-rolling application, will help you level up your Python programming skills. You’ll learn how to gather and validate the user’s input, import code from modules and packages, write functions, use for loops and conditionals, and neatly display output by using strings and the print() function.

In this project, you’ll code an application that simulates dice-rolling events. To do so, you’ll use Python’s random module.

In this tutorial, you’ll learn how to:

Use random.randint() to simulate dice-rolling events
Ask for the user’s input using the built-in input() function
Parse and validate the user’s input
Manipulate strings using methods, such as .center() and .join()

You’ll also learn the basics of how to structure, organize, document, and run your Python programs and scripts.

Click the link below to download the entire code for this dice-rolling application and follow along while you build the project yourself:

Get Source Code: Click here to get the source code you’ll use to build your Python dice-rolling app.

Demo

In this step-by-step project, you’ll build an application that runs dice-rolling simulations. The app will be able to roll up to six dice, with each die having six faces. After every roll, the application will generate an ASCII diagram of dice faces and display it on the screen. The following video demonstrates how the app works:

When you run your dice-rolling simulator app, you get a prompt asking for the number of dice you want to roll. Once you provide a valid integer from 1 to 6, inclusive, then the application simulates the rolling event and displays a diagram of dice faces on the screen.

Project Overview

Your dice-rolling simulator app will have a minimal yet user-friendly text-based user interface (TUI), which will allow you to specify the number of six-sided dice that you’d like to roll. You’ll use this TUI to roll the dice at home without having to fly to Las Vegas.

Here’s a description of how the app will work internally:

Tasks to Run	Tools to Use	Code to Write
Prompt the user to choose how many six-sided dice to roll, then read the user’s input	Python’s built-in `input()` function	A call to `input()` with appropriate arguments
Parse and validate the user’s input	String methods, comparison operators, and conditional statements	A user-defined function called `parse_input()`
Run the dice-rolling simulation	Python’s `random` module, specifically the `randint()` function	A user-defined function called `roll_dice()`
Generate an ASCII diagram with the resulting dice faces	Loops, `list.append()`, and `str.join()`	A user-defined function called `generate_dice_faces_diagram()`
Display the diagram of dice faces on the screen	Python’s built-in `print()` function	A call to `print()` with appropriate arguments

Keeping these internal workings in mind, you’ll code three custom functions to provide the app’s main features and functionalities. These functions will define your code’s public API, which you’ll call to bring the app to life.

To organize the code of your dice-rolling simulator project, you’ll create a single file called dice.py in a directory of your choice in your file system. Go ahead and create the file to get started!

Prerequisites

You should be comfortable with the following concepts and skills before you start building this dice-rolling simulation project:

Ways to run scripts in Python
Python’s import mechanism
The basics of Python data types, mainly strings and integer numbers
Basic data structures, especially lists
Python variables and constants
Python comparison operators
Boolean values and logical expressions
Conditional statements
Python for loops
The basics of input, output, and string formatting in Python

If you don’t have all of the prerequisite knowledge before starting this coding adventure, then that’s okay! You might learn more by going ahead and getting started! You can always stop and review the resources linked here if you get stuck.

Step 1: Code the TUI of Your Python Dice-Rolling App

In this step, you’ll write the required code to ask for the user’s input of how many dice they want to roll in the simulation. You’ll also code a Python function that takes the user’s input, validates it, and returns it as an integer number if the validation was successful. Otherwise, the function will ask for the user’s input again.

To download the code for this step, click the following link and navigate to the source_code_step_1/ folder:

Get Source Code: Click here to get the source code you’ll use to build your Python dice-rolling app.

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

[ 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 ]

Starting With Python IDLE

2022-01-18T14:00:00+00:00

If you’ve recently downloaded Python onto your computer, then you may have noticed a new program on your machine called IDLE. You might be wondering, “What is this program doing on my computer? I didn’t download that!” While you may not have downloaded this program on your own, IDLE comes bundled with every Python installation. It’s there to help you get started with the language right out of the box. In this course, you’ll learn how to work in Python IDLE and a few cool tricks you can use on your Python journey!

In this course, you’ll learn:

What Python IDLE is
How to interact with Python directly using IDLE
How to edit, execute, and debug Python files with IDLE
How to customize Python IDLE to your liking

[ 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 December 2021?

2022-01-17T14:00:00+00:00

In December 2021, the fourth Python steering council was elected, as usual with a mix of new and returning members. Python’s release-cycle circle of life kept spinning, with new iterations of both Python 3.10 and the upcoming Python 3.11 released. At the same time, the popular Python 3.6 reached end-of-life and will no longer be supported.

Amid this flurry of activity, developers from all over had some fun over the holidays by solving the annual Advent of Code puzzles.

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

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.

Python Steering Council Elections

Guido van Rossum is the creator of Python. For a long time, he was also the Benevolent Dictator For Life (BDFL) of the language, in charge of overseeing all changes that were implemented.

During the summer of 2018, Guido resigned as BDFL and asked the community to come up with a new model for governance of the language. After some discussion, the community decided that a steering council should be elected to direct the development of Python.

A new steering council is elected regularly, more or less coinciding with each release of Python. The terms are therefore often labeled by the corresponding version of Python that will be released during that term. The most recent election, for the Python 3.11 term, was held in the first half of December, with the final results announced on December 17.

Since the first steering council was elected in January 2019, the following members have served:

Barry Warsaw (3.8, 3.9, 3.10)
Brett Cannon (3.8, 3.9, 3.10)
Carol Willing (3.8, 3.9, 3.10)
Guido van Rossum (3.8)
Nick Coghlan (3.8)
Pablo Galindo Salgado (3.10)
Thomas Wouters (3.9, 3.10)
Victor Stinner (3.9)

Read the full article at https://realpython.com/python-news-december-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 #93: Launching Python, Virtual Environments, and Locking Dependencies With Brett Cannon

2022-01-14T12:00:00+00:00

Would you like a simple command to launch your Python programs using the newest version of the language installed on your machine? This week on the show, we continue our conversation with Brett Cannon. Brett discusses his project, the Python Launcher for Unix.

[ 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 ]

Working With Pipenv

2022-01-11T14:00:00+00:00

Managing multiple Python projects with their own third-party packages can get complicated. It is best practice to use a virtual environment to sandbox the requirements for each of your projects. Enter pipenv, the official recommended package management tool for Python. It handles both installation and virtual environments to help you manage your Python dependencies.

In this course, you’ll learn about:

How to use pip to install a package
Where Python puts packages by default
How to use pipenv to create virtual environments and install packages
How pipenv handles package conflicts

[ 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 #92: Continuing to Unravel Python's Syntactic Sugar With Brett Cannon

2022-01-07T12:00:00+00:00

A year ago, we had Brett Cannon on the show to discuss his blog series about unravelling Python's syntactic sugar. Brett has written 15 more entries in the series, and he returns to the show this week to continue our conversation. We dive into unravelling 'async' and 'await' statements and their relationship with Python's generators.

[ 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 ]

Deploy Your Python Script on the Web With Flask

2022-01-04T14:00:00+00:00

You wrote a Python script that you’re proud of, and now you want to show it off to the world. But how? Most people won’t know what to do with your .py file. Converting your script into a Python web application is a great solution to make your code usable for a broad audience.

In this course, you’ll learn how to go from a local Python script to a fully deployed Flask web application that you can share with the world.

By the end of this course, you’ll know:

What web applications are and how you can host them online
How to convert a Python script into a Flask web application
How to improve user experience by adding HTML to your Python code
How to deploy your Python web application to Google App Engine

[ 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 #91: 2021 Real Python Articles Wrap Up

2021-12-24T12:00:00+00:00

It's been a year of change at Real Python! The Real Python team has written, edited, curated, illustrated, and produced a mountain of Python articles this year. We also added many new members to the team, updated the site's features, and created new styles of tutorials 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 ]

Raising and Handling Python Exceptions

2021-12-21T14:00:00+00:00

A Python program terminates as soon as it encounters an error. In Python, an error can be a syntax error or an exception.

In this course, you’ll learn what an exception is and how it differs from a syntax error. After that, you’ll learn about raising exceptions and making assertions. Then, you’ll learn how to catch exceptions to prevent your program from unintentionally ending and to change the control flow of your program:

You’ll learn about the basic use of a try … except block, as well as how to extend it using else and finally.

In this course, you’ll learn how to:

Differentiate exceptions from syntax errors
Use the assert keyword to check if a certain condition is met
Write custom exceptions that subclass Exception
Catch exceptions with a try … except block
Use the additional keywords else and finally
Catch built-in exceptions

[ 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 #90: A Python Journey: Cyber Security, Automating AWS, and TDD

2021-12-17T12:00:00+00:00

The Python community continually grows, with many users coming from different languages and backgrounds. This week on the show, we talk with developer Hugh Tipping about his Python journey. Hugh is also a member of the Real Python community.

[ 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 ]

Host Your Django Project on Heroku

2021-12-14T14:00:00+00:00

As a novice web developer, you’ve built your portfolio app and shared your code on GitHub. Perhaps, you’re hoping to attract technical recruiters to land your first programming job. Many coding bootcamp graduates are likely doing the same thing. To differentiate yourself from the crowd and boost your chances of getting noticed, you can start hosting your Django project online.

For a hobby Django project, you’ll want a hosting service that’s free of charge, quick to set up, user-friendly, and well-integrated with your existing technology stack. While GitHub Pages is perfect for hosting static websites and websites with JavaScript, you’ll need a web server to run your Flask or Django project.

There are a few major cloud platform providers operating in different models, but you’re going to explore Heroku in this course. It ticks all the boxes—it’s free, quick to set up, user-friendly, and well-integrated with Django—and is the favorite cloud platform provider of many startups.

In this course, you’ll learn how to:

Sign up for a free Heroku account
Use the Heroku CLI (command-line interface)
Bootstrap a minimal Django project
Integrate Git with Heroku
Connect to Heroku’s PostgreSQL database
Manage configuration, make new releases and rollbacks

[ 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 #89: Solving Advent of Code Puzzles With Python

2021-12-10T12:00:00+00:00

Are you ready to break open the first days of puzzles from the annual Advent of Code challenge? Advent of Code is an advent calendar of twenty-five programming puzzles published each December. Practicing solving puzzles is a great way to build your Python skills. This week on the show, we have previous guest and Real Python author Geir Arne Hjelle to discuss his recent article titled, "Advent of Code: Solving Your Puzzles With 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 ]

Binary, Bytes, and Bitwise Operators in Python

2021-12-07T14:00:00+00:00

Computers store all kinds of information as a stream of binary digits called bits. Whether you’re working with text, images, or videos, they all boil down to ones and zeros. Python’s bitwise operators let you manipulate those individual bits of data at the most granular level.

Python isolates you from the underlying bits with high-level abstractions. You’re more likely to find the overloaded flavors of bitwise operators in practice. But when you work with them in their original form, you’ll be surprised by their quirks!

In this course, you’ll learn how to:

Read binary numbers
Perform bitwise math and read truth tables
Represent fixed and arbitrary precision itegers in Python
Perform bitwise operations in Python
Use bitmasks to pack information on a single byte
Differentiate Big-Endian and Little-Endian byte orders
Overload Python bitwise operators in custom data types

[ 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

The Real Python Podcast – Episode #98: Drawing Fractals With Python and Working With a Weather API

Providing Multiple Constructors in Your Python Classes

Instantiating Classes in Python

Python any(): Powered Up Boolean Function

Python's zipfile: Manipulate Your ZIP Files Efficiently

Getting Started With ZIP Files

What Is a ZIP File?

Why Use ZIP Files?

The Real Python Podcast – Episode #97: Improving Your Django and Python Developer Experience

Python's all(): Check Your Iterables for Truthiness

Evaluating the Truth Value of Items in Iterables

Defining Python Functions With Optional Arguments

Python News: What's New From January 2022?

Black No Longer Beta

The Real Python Podcast – Episode #96: Manipulating and Analyzing Audio in Python

Using Python's pip to Manage Your Projects' Dependencies

Getting Started With pip

Finding pip on Your System

Running pip as a Module

Using pip in a Python Virtual Environment

Python's len() Function

Draw the Mandelbrot Set in Python

Understanding the Mandelbrot Set

The Icon of Fractal Geometry

The Boundary of Iterative Stability

The Real Python Podcast – Episode #95: What Is a JIT and How Can Pyjion Speed Up Your Python?

Raining Outside? Build a Weather CLI App With Python

Demo

Project Overview

Prerequisites

Step 1: Get Access to a Suitable Weather API

Looping With Python enumerate()

Modulo String Formatting in Python

Use the Modulo Operator for String Formatting in Python

The Real Python Podcast – Episode #94: Designing for Users and Building a Social Network With Django

Build a Dice-Rolling Application With Python

Demo

Project Overview

Prerequisites

Step 1: Code the TUI of Your Python Dice-Rolling App

Starting With Python IDLE

Python News: What's New From December 2021?

Python Steering Council Elections

The Real Python Podcast – Episode #93: Launching Python, Virtual Environments, and Locking Dependencies With Brett Cannon

Working With Pipenv

The Real Python Podcast – Episode #92: Continuing to Unravel Python's Syntactic Sugar With Brett Cannon

Deploy Your Python Script on the Web With Flask

The Real Python Podcast – Episode #91: 2021 Real Python Articles Wrap Up

Raising and Handling Python Exceptions

The Real Python Podcast – Episode #90: A Python Journey: Cyber Security, Automating AWS, and TDD

Host Your Django Project on Heroku

The Real Python Podcast – Episode #89: Solving Advent of Code Puzzles With Python

Binary, Bytes, and Bitwise Operators in Python

Getting Started With `pip`

Finding `pip` on Your System

Running `pip` as a Module

Using `pip` in a Python Virtual Environment