Real Python

The Real Python Podcast – Episode #284: Running Local LLMs With Ollama and Connecting With Python

2026-02-13T12:00:00+00:00

Would you like to learn how to work with LLMs locally on your own computer? How do you integrate your Python projects with a local model? Christopher Trudeau is back on the show this week with 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 ]

Quiz: Python's list Data Type: A Deep Dive With Examples

2026-02-12T12:00:00+00:00

Get hands-on with Python lists in this quick quiz. You’ll revisit indexing and slicing, update items in place, and compare list methods.

Along the way, you’ll look at reversing elements, using the list() constructor and the len() function, and distinguishing between shallow and deep copies. For a refresher, see the Real Python guide to Python lists.

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

What Exactly Is the Zen of Python?

2026-02-11T14:00:00+00:00

The Zen of Python is a collection of 19 aphorisms that capture the guiding principles behind Python’s design. You can display them anytime by running import this in a Python REPL. Tim Peters wrote them in 1999 as a joke, but they became an iconic part of Python culture that was even formalized as PEP 20.

By the end of this tutorial, you’ll understand:

The Zen of Python is a humorous poem of 19 aphorisms describing Python’s design philosophy
Running import this in a Python interpreter displays the complete text of the Zen of Python
Tim Peters wrote the Zen of Python in 1999 as a tongue-in-cheek comment on a mailing list
The aphorisms are guidelines, not strict rules, and some intentionally contradict each other
The principles promote readability, simplicity, and explicitness while acknowledging that practicality matters

Experienced Pythonistas often refer to the Zen of Python as a source of wisdom and guidance, especially when they want to settle an argument about certain design decisions in a piece of code. In this tutorial, you’ll explore the origins of the Zen of Python, learn how to interpret its mysterious aphorisms, and discover the Easter eggs hidden within it.

You don’t need to be a Python master to understand the Zen of Python! But you do need to answer an important question: What exactly is the Zen of Python?

Free Bonus: Click here to download your Easter egg hunt to discover what’s hidden inside Python!

Take the Quiz: Test your knowledge with our interactive “What Exactly Is the Zen of Python?” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

What Exactly Is the Zen of Python?

Learn and test the Zen of Python, its guiding aphorisms, and tips for writing clearer, more readable, and maintainable code.

In Short: It’s a Humorous Poem Listing Python Philosophies

According to the Python glossary, which contains definitions of popular terms related to this programming language, the Zen of Python is a:

Listing of Python design principles and philosophies that are helpful in understanding and using the language. The listing can be found by typing “import this” at the interactive prompt. (Source)

Indeed, when you type the indicated import statement into an interactive Python REPL, then you’ll be presented with the nineteen aphorisms that make up the Zen of Python:

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

The byline reveals the poem’s author, Tim Peters, who’s a renowned software engineer and a long-standing CPython core developer best known for inventing the Timsort sorting algorithm. He also authored the doctest and timeit modules in the Python standard library, along with making many other contributions.

Take your time to read through the Zen of Python and contemplate its wisdom. But don’t take the aphorisms literally, as they’re more of a guiding set of principles rather than strict instructions. You’ll learn about their humorous origins in the next section.

How Did the Zen of Python Originate?

The idea of formulating a single document that would encapsulate Python’s fundamental philosophies emerged among the core developers in June 1999. As more and more people began coming to Python from other programming languages, they’d often bring their preconceived notions of software design that weren’t necessarily Pythonic. To help them follow the spirit of the language, a set of recommendations for writing idiomatic Python was needed.

The initial discussion about creating such a document took place on the Python mailing list under the subject The Python Way. Today, you can find this conversation in the official Python-list archive. If you look closely at the first message from Tim Peters in that thread, then you’ll notice that he clearly outlined the Zen of Python as a joke. That original form has stuck around until this day:

Clearly a job for Guido alone – although I doubt it’s one he’ll take on (fwiw, I wish he would too!). Here’s the outline he would start from, though <wink>:

Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren’t special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one– and preferably only one –obvious way to do it. Although that way may not be obvious at first unless you’re Dutch. Now is better than never. Although never is often better than right now. If the implementation is hard to explain, it’s a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea – let’s do more of those!

There you go: 20 Pythonic Fec^H^H^HTheses on the nose, counting the one I’m leaving for Guido to fill in. If the answer to any Python design issue isn’t obvious after reading those – well, I just give up <wink>. (Source)

The wink and the playful way of self-censoring some toilet humor are clear giveaways that Tim Peters didn’t want anyone to take his comment too seriously.

Note: In case you didn’t get the joke, he started to write something like Feces but then used ^H—which represents a Backspace in older text editors like Vim—to delete the last three letters and make the word Theses. Therefore, the intended phrase is 20 Pythonic Theses.

Eventually, these nearly twenty theses got a proper name and were formally codified in a Python Enhancement Proposal document. Each PEP document receives a number. For example, you might have stumbled on PEP 8, which is the style guide for writing readable Python code. Perhaps as an inside joke, the Zen of Python received the number PEP 20 to signify the incomplete number of aphorisms in it.

To win your next argument about what makes good Python code, you can back up your claims with the Zen of Python. If you’d like to refer to a specific aphorism instead of the entire poem, then consider visiting pep20.org, which provides convenient clickable links to each principle.

And, in case you want to learn the poem by heart while having some fun, you can now listen to a song with the Zen of Python as its lyrics. Barry Warsaw, another core developer involved with Python since its early days, composed and performed this musical rendition. The song became the closing track on a special vinyl record entitled The Zen Side of the Moon, which was auctioned at PyCon US 2023.

Okay. Now that you have a rough idea of what the Zen of Python is and how it came about, you might be asking yourself whether you should really follow it.

Should You Obey the Zen of Python?

Read the full article at https://realpython.com/zen-of-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 ]

Quiz: What Exactly Is the Zen of Python?

2026-02-11T12:00:00+00:00

In this quiz, you’ll test your understanding of The Zen of Python.

By working through this quiz, you’ll revisit core aphorisms and learn how they guide readable, maintainable, and Pythonic code.

The questions explore practical tradeoffs like breaking dense expressions into smaller parts, favoring clarity over cleverness, and making code behavior explicit.

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

Improving Your Tests With the Python Mock Object Library

2026-02-10T14:00:00+00:00

When you’re writing robust code, tests are essential for verifying that your application logic is correct, reliable, and efficient. However, the value of your tests depends on how well they demonstrate these qualities. Obstacles such as complex logic and unpredictable dependencies can make writing valuable tests challenging. The Python mock object library, unittest.mock, can help you overcome these obstacles.

By the end of this course, you’ll be able to:

Create Python mock objects using Mock
Assert that you’re using objects as you intended
Inspect usage data stored on your Python mocks
Configure certain aspects of your Python mock objects
Substitute your mocks for real objects using patch()
Avoid common problems inherent in Python mocking

You’ll begin by learning what mocking is and how it will improve your tests!

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

Quiz: Python's pathlib Module: Taming the File System

2026-02-10T12:00:00+00:00

In this quiz, you’ll revisit how to tame the file system with Python’s pathlib module.

You’ll reinforce core pathlib concepts, including checking whether a path points to a file and instantiating Path objects. You’ll revisit joining paths with the / operator and .joinpath(), iterating over directory contents with .iterdir(), and renaming files on disk with .replace().

You’ll also check your knowledge of common file operations such as creating empty files with .touch(), writing text with .write_text(), and extracting filename components using .stem and .suffix.

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

pandas 3.0 Lands Breaking Changes and Other Python News for February 2026

2026-02-09T14:00:00+00:00

Last month brought exciting performance news for Python! The Python 3.15 alphas showed JIT compiler speed gains of up to 7–8% on some platforms, while pandas released version 3.0, delivering the most significant performance improvements in years. The Python Software Foundation also received considerable investments in Python security and launched the 2026 Python Developers Survey, and PyTorch 2.10 deprecated TorchScript.

Time to dive into the biggest Python news from the past month!

Join Now: Click here to join the Real Python Newsletter and you’ll never miss another Python tutorial, course, or news update.

Python Releases and PEP Highlights

Last month brought two Python 3.15 alpha releases in quick succession, with notable JIT compiler improvements showing promising performance gains. Several PEPs also emerged, including one proposing a cleaner way to write multiline strings.

Python 3.15.0 Alpha 4 and 5: Two Releases in Two Days

January saw an unusual situation in Python’s release history: Python 3.15.0a4 arrived on January 13, but it was accidentally compiled against outdated source code from December 2025. The release team quickly followed up with 3.15.0a5 on January 14 to correct the issue.

Both releases continue the work on Python 3.15’s headline features:

UTF-8 as the default text encoding for files that don’t specify an encoding, via PEP 686
A new statistical sampling profiler that’s high-frequency and low-overhead, via PEP 799
The PyBytesWriter C API for creating bytes objects more efficiently, via PEP 782
Enhanced error messages with improved clarity and usefulness

The most exciting news for performance enthusiasts is the continued progress on Python’s experimental JIT compiler. Alpha 5 reports a 4–5% performance improvement on x86-64 Linux and a 7–8% speedup on AArch64 macOS compared to the standard interpreter.

Note: These are preview releases and are not recommended for production. The beta phase begins May 5, 2026, with the next alpha, 3.15.0a6, scheduled for February 10, 2026.

If you maintain packages, now is a good time to start running tests against the alphas in a separate environment so you can catch regressions early.

PEP 822 Drafted: Dedented Multiline Strings (d-strings)

A new PEP emerged in January that could make writing multiline strings clearer. PEP 822, authored by Inada Naoki, proposes adding dedented multiline strings (d-strings) to Python.

If you’ve ever written a multiline string inside an indented function or class, you’ve likely run into the awkward choice between breaking your code’s visual structure or using textwrap.dedent() to clean up the extra whitespace. PEP 822 offers a cleaner solution with a new d prefix:

def get_help_message():
    # Current approach
    return textwrap.dedent("""\
        Usage: app [options]

        Options:
            -h  Show this help message
            -v  Enable verbose mode
        """)

    # Proposed d-string approach
    return d"""
        Usage: app [options]

        Options:
            -h  Show this help message
            -v  Enable verbose mode
        """

The d prefix tells Python to automatically strip the common leading whitespace from each line, using the indentation of the closing quotes as a reference. This differs slightly from textwrap.dedent(), which uses the least-indented line to determine how much to strip.

The proposal targets Python 3.15 and is currently in draft status. If you work with templates, SQL queries, or any code that embeds multiline text, this feature could simplify your workflow. You can follow the discussion on the Python Discourse and provide feedback while the PEP is still being refined.

PSF News: Investments, Fellows, and Survey

The Python Software Foundation (PSF) had a busy month with a major security investment announcement, new Fellows recognition, and the launch of the annual developers survey.

Anthropic Invests in Python Security

Read the full article at https://realpython.com/python-news-february-2026/ »

[ 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 #283: Improving Your GitHub Developer Experience

2026-02-06T12:00:00+00:00

What are ways to improve how you're using GitHub? How can you collaborate more effectively and improve your technical writing? This week on the show, Adam Johnson is back to talk about his new book, "Boost Your GitHub DX: Tame the Octocat and Elevate Your Productivity".

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

Why You Should Attend a Python Conference

2026-02-04T14:00:00+00:00

The idea of attending a Python conference can feel intimidating. You might wonder if you know enough, if you’ll fit in, or if it’s worth your time and money. In this guide, you’ll learn about the different types of Python conferences, what they actually offer, who they’re for, and how attending one can support your learning, confidence, and connection to the wider Python community.

Prerequisites

This guide is for all Python users who want to grow their Python knowledge, get involved with the Python community, or explore new professional opportunities. Your level of experience with Python doesn’t matter, and neither does whether you use Python professionally or as a hobbyist—regularly or only from time to time. If you use Python, you’re a Python developer, and Python conferences are for Python developers!

Brett Cannon, a CPython core developer, once said:

I came for the language, but I stayed for the community. (Source)

If you want to experience this feeling firsthand, then this guide is for you.

Get Your PDF: Click here to download a PDF with practical tips to help you feel prepared for your first Python conference.

Understand What Python Conferences Actually Offer

Attending a Python conference offers several distinct benefits that generally fall into three categories:

Personal growth: Learn new concepts, tools, and best practices through talks, tutorials, and hands-on sessions that help you deepen your Python skills and build confidence.
Community involvement: Meet other Python users in person, connect with open-source contributors and maintainers, and experience the collaborative culture that defines the Python community.
Professional opportunities: Discover potential job openings, meet companies using Python across industries, and form professional connections that can lead to future projects or roles.

The following sections explore each category in more detail to help you recognize what matters most to you when choosing a Python conference.

Personal Growth

One of the biggest benefits of attending a Python conference is the opportunity for personal growth through active learning and engagement.

Python conferences are organized around a program of talks, tutorials, and collaborative sessions that expose you to new ideas, tools, and ways of thinking about Python. The number of program items can range from one at local meetups to over one hundred at larger conferences like PyCon US and EuroPython.

At larger events, you’re exposed to a wide breadth of topics to choose from, while at smaller events, you have fewer options but can usually attend all the sessions you’re interested in. Conference talks are an excellent opportunity to get exposed to new ideas, hear about new tools, or just listen to someone else talk about a topic you’re familiar with, which can be a very educational experience!

Most of these talks are later shared on YouTube, but attending in person allows you to participate in live Q&A sessions where speakers answer audience questions directly. You also have the chance to meet the speaker after the talk and ask follow-up questions that wouldn’t be possible when watching a recording.

Tutorials, on the other hand, are rarely recorded. They tend to be longer than talks and focus on hands-on coding, making them a brilliant way to gain practical, working knowledge of a Python feature or tool. Working through exercises with peers and asking questions in real time can help solidify your understanding of a topic.

Some conferences also include collaborative sprint events, where you get together with other attendees to contribute to open-source projects, typically with the guidance of the project maintainers themselves:

Participating in sprints under the mentorship of the project maintainers is a great way to boost your confidence in your skills and get some open-source contributions under your belt.

Community Involvement

Developers are used to collaborating on open-source projects with people around the world, but working together online isn’t the same as having a face-to-face conversation. Python conferences fill that gap by giving developers a dedicated space to meet and connect in person.

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

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

Getting Started With Google Gemini CLI

2026-02-03T14:00:00+00:00

This video course will teach you how to use Gemini CLI to bring Google’s AI-powered coding assistance directly into your terminal. After you authenticate with your Google account, this tool will be ready to help you analyze code, identify bugs, and suggest fixes—all without leaving your familiar development environment.

Imagine debugging code without switching between your console and browser, or picture getting instant explanations for unfamiliar projects. Like other command-line AI assistants, Google’s Gemini CLI brings AI-powered coding assistance directly into your command line, allowing you to stay focused in your development workflow.

Whether you’re troubleshooting a stubborn bug, understanding legacy code, or generating documentation, this tool acts as an intelligent pair-programming partner that understands your codebase’s context.

You’re about to install Gemini CLI, authenticate with Google’s free tier, and put it to work on an actual Python project. You’ll discover how natural language queries can help you understand code faster and catch bugs that might slip past manual review.

[ 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 Terminal: First Steps and Useful Commands for Python Developers

2026-02-02T14:00:00+00:00

The terminal provides Python developers with direct control over their operating system through text commands. Instead of clicking through menus, you type commands to navigate folders, run scripts, install packages, and manage version control. This command-line approach is faster and more flexible than graphical interfaces for many development tasks.

By the end of this tutorial, you’ll understand that:

Terminal commands like cd, ls, and mkdir let you navigate and organize your file system efficiently
Virtual environments isolate project dependencies, keeping your Python installations clean and manageable
pip installs, updates, and removes Python packages directly from the command line
Git commands track changes to your code and create snapshots called commits
The command prompt displays your current directory and indicates when the terminal is ready for input

This tutorial walks through the fundamentals of terminal usage on Windows, Linux, and macOS. The examples cover file system navigation, creating files and folders, managing packages with pip, and tracking code changes with Git.

Get Your Cheat Sheet: Click here to download a free cheat sheet of useful commands to get you started working with the terminal.

Install and Open the Terminal

Back in the day, the term terminal referred to some clunky hardware that you used to enter data into a computer. Nowadays, people are usually talking about a terminal emulator when they say terminal, and they mean some kind of terminal software that you can find on most modern computers.

Note: There are two other terms that you might hear now and then in combination with the terminal:

A shell is the program that you interact with when running commands in a terminal.
A command-line interface (CLI) is a program designed to run in a shell inside the terminal.

In other words, the shell provides the commands that you use in a command-line interface, and the terminal is the application that you run to access the shell.

If you’re using a Linux or macOS machine, then the terminal is already built in. You can start using it right away.

On Windows, you also have access to command-line applications like the Command Prompt. However, for this tutorial and terminal work in general, you should use the Windows terminal application instead.

Read on to learn how to install and open the terminal on Windows and how to find the terminal on Linux and macOS.

Windows

The Windows terminal is a modern and feature-rich application that gives you access to the command line, multiple shells, and advanced customization options. If you have Windows 11 or above, chances are that the Windows terminal is already present on your machine. Otherwise, you can download the application from the Microsoft Store or from the official GitHub repository.

Before continuing with this tutorial, you need to get the terminal working on your Windows computer. You can follow the Your Python Coding Environment on Windows: Setup Guide to learn how to install the Windows terminal.

After you install the Windows terminal, you can find it in the Start menu under Terminal. When you start the application, you should see a window that looks like this:

It can be handy to create a desktop shortcut for the terminal or pin the application to your task bar for easier access.

Linux

You can find the terminal application in the application menu of your Linux distribution. Alternatively, you can press Ctrl+Alt+T on your keyboard or use the application launcher and search for the word Terminal.

After opening the terminal, you should see a window similar to the screenshot below:

How you open the terminal may also depend on which Linux distribution you’re using. Each one has a different way of doing it. If you have trouble opening the terminal on Linux, then the Real Python community will help you out in the comments below.

macOS

A common way to open the terminal application on macOS is by opening the Spotlight Search and searching for Terminal. You can also find the terminal app in the application folder inside Finder.

When you open the terminal, you see a window that looks similar to the image below:

Read the full article at https://realpython.com/terminal-commands/ »

[ 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 #282: Testing Python Code for Scalability & What's New in pandas 3.0

2026-01-30T12:00:00+00:00

How do you create automated tests to check your code for degraded performance as data sizes increase? What are the new features in pandas 3.0? Christopher Trudeau is back on the show this week with 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 ]

How Long Does It Take to Learn Python?

2026-01-28T14:00:00+00:00

Have you read blog posts that claim you can learn Python in days and quickly secure a high-paying developer job? That’s an unlikely scenario and doesn’t help you prepare for a steady learning marathon. So, how long does it really take to learn Python, and is it worth your time investment?

By the end of this guide, you’ll understand that:

Most beginners can learn core Python fundamentals in about 2 to 6 months with consistent practice.
You can write a tiny script in days or weeks, but real confidence comes from projects and feedback.
Becoming job-ready often takes 6 to 12 months, depending on your background and target role.
Mastery takes years because the ecosystem and specializations keep growing.

The short answer for how long it takes to learn Python depends on your goals, time budget, and the level you’re aiming for.

Get the PDF Guide: Click here to download a free PDF guide that breaks down how long it takes to learn Python and what factors affect your timeline.

Take the Quiz: Test your knowledge with our interactive “Python Skill Test” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python Skill Test

Test your Python knowledge in a skills quiz with basic to advanced questions. Are you a Novice, Intermediate, Proficient, or Expert?

How Long Does It Take to Learn Python Basics?

Python is beginner-friendly, and you can start writing simple programs in just a few days. But reaching the basics stage still takes consistent practice because you’re learning both the language itself and how to think like a programmer.

The following timeline shows how long it typically takes to learn Python basics based on how much time you can practice each week:

Weekly practice time	Typical timeline for basics	What that feels like
2–3 hours/week	8–12 months	Slow but steady progress
5–10 hours/week	3–6 months	Realistic pace for busy adults
15–20 hours/week	~2 months	Consistent focus and fast feedback
40+ hours/week	~1 month	Full-time immersion

These ranges assume about five study days per week. If you add a sixth day, you’ll likely land toward the faster end of each range.

You’ll get better results if you use this table as a planning guide. Don’t think of it as rigid deadlines—your learning pace depends on many factors. For example, if you already know another programming language, then you can usually move faster. If you’re brand-new to coding, then expect to be at the slower end of each range.

As a general guideline, many beginners reach the basics in about 2 to 6 months with steady practice.

Note: If you’re ready to fast-track your learning with an expert-guided small cohort course that gives you live guidance and accountability, then check out Real Python’s live courses!

With a focused schedule of around four hours per day, five days per week, you can often reach the basics stage in roughly 6 to 10 weeks, assuming you’re writing and debugging code most sessions. By then, you should be able to finish several small projects on your own.

When you read online that someone learned Python quickly, they’re probably talking about this basics stage. And indeed, with the right mix of dedication, circumstances, and practice, learning Python basics can happen pretty fast!

Before you go ahead and lock in a timeline, take a moment to clarify for yourself why you want to learn Python. Understanding your motivation for learning Python will help along the way.

Learning Python means more than just learning the Python programming language. You need to know more than just the specifics of a single programming language to do something useful with your programming skills. At the same time, you don’t need to understand every single aspect of Python to be productive.

Learning Python is about learning how to accomplish practical tasks with Python programming. It’s about having a skill set that you can use to build projects for yourself or an employer.

As your next step, write down your personal goal for learning Python. Always keep that goal in mind throughout your learning journey. Your goal shapes what you need to learn and how quickly you’ll progress.

What’s a Practical 30-Day Learning Plan for Complete Beginners?

When you’re clear about your why, you can start drafting your personal Python learning roadmap.

If you’re starting from zero and can spend about 5 to 10 hours per week, the following plan keeps you moving without becoming overwhelming:

Week 1: Install and set up Python, learn about basic syntax, variables, and conditional statements
Week 2: Learn about basic data types, for and while loops, and functions
Week 3: Work with lists and dictionaries, file I/O, and debugging basics
Week 4: Build a small project, add simple tests, and polish it through refactoring

Aim to finish at least one small project by the end of the month. The project matters more than completing every tutorial or task on your checklist.

Read the full article at https://realpython.com/how-long-does-it-take-to-learn-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 ]

Create Callable Instances With Python's .call()

2026-01-27T14:00:00+00:00

In Python, a callable is any object that you can call using a pair of parentheses and, optionally, a series of arguments. Functions, classes, and methods are all common examples of callables in Python. Besides these, you can also create custom classes that produce callable instances. To do this, you can add the .__call__() special method to your class.

Instances of a class with a .__call__() method behave like functions, providing a flexible and handy way to add functionality to your objects. Understanding how to create and use callable instances is a valuable skill for any Python developer.

In this video course, you’ll:

Understand the concept of callable objects in Python
Create callable instances by adding a .__call__() method to your classes
Compare .__init__() and .__call__() and understand their distinct roles
Build practical examples that use callable instances to solve real-world problems

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

GeoPandas Basics: Maps, Projections, and Spatial Joins

2026-01-26T14:00:00+00:00

GeoPandas extends pandas to make working with geospatial data in Python intuitive and powerful. If you’re looking to do geospatial tasks in Python and want a library with a pandas-like API, then GeoPandas is an excellent choice. This tutorial shows you how to accomplish four common geospatial tasks: reading in data, mapping it, applying a projection, and doing a spatial join.

By the end of this tutorial, you’ll understand that:

GeoPandas extends pandas with support for spatial data. This data typically lives in a geometry column and allows spatial operations such as projections and spatial joins, while Folium focuses on richer interactive web maps after data preparation.
You inspect CRS with .crs and reproject data using .to_crs() with an authority code like EPSG:4326 or ESRI:54009.
A geographic CRS stores longitude and latitude in degrees, while a projected CRS uses linear units like meters or feet for area and distance calculations.
Spatial joins use .sjoin() with predicates like "within" or "intersects", and both inputs must share the same CRS or the relationships will be computed incorrectly.

Here’s how GeoPandas compares with alternative libraries:

Use Case	Pick pandas	Pick Folium	Pick GeoPandas
Tabular data analysis	✅	-	✅
Mapping	-	✅	✅
Projections, spatial joins	-	-	✅

GeoPandas builds on pandas by adding support for geospatial data and operations like projections and spatial joins. It also includes tools for creating maps. Folium complements this by focusing on interactive, web-based maps that you can customize more deeply.

Get Your Code: Click here to download the free sample code for learning how to work with GeoPandas maps, projections, and spatial joins.

Take the Quiz: Test your knowledge with our interactive “GeoPandas Basics: Maps, Projections, and Spatial Joins” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

GeoPandas Basics: Maps, Projections, and Spatial Joins

Test GeoPandas basics for reading, mapping, projecting, and spatial joins to handle geospatial data confidently.

Getting Started With GeoPandas

You’ll first prepare your environment and load a small dataset that you’ll use throughout the tutorial. In the next two subsections, you’ll install the necessary packages and read in a sample dataset of New York City borough boundaries. This gives you a concrete GeoDataFrame to explore as you learn the core concepts.

Installing GeoPandas

This tutorial uses two packages: geopandas for working with geographic data and geodatasets for loading sample data. It’s a good idea to install these packages inside a virtual environment so your project stays isolated from the rest of your system and you can manage its dependencies cleanly.

Once your virtual environment is active, you can install both packages with pip:

$ python -m pip install "geopandas[all]" geodatasets

Using the [all] option ensures you have everything needed for reading data, transforming coordinate systems, and creating plots. For most readers, this will work out of the box.

If you do run into installation issues, the project’s maintainers provide alternative installation options on the official installation page.

Reading in Data

Most geospatial datasets come in GeoJSON or shapefile format. The read_file() function can read both, and it accepts either a local file path or a URL.

In the example below, you’ll use read_file() to load the New York City Borough Boundaries (NYBB) dataset. The geodatasets package provides a convenient path to this dataset, so you don’t need to download anything manually. You’ll also drop unnecessary columns:

>>> import geopandas as gpd
>>> import matplotlib.pyplot as plt
>>> from geodatasets import get_path
>>> path_to_data = get_path("nybb")
>>> nybb = gpd.read_file(path_to_data)
>>> nybb = nybb[["BoroName", "Shape_Area", "geometry"]]
>>> nybb
    BoroName        Shape_Area      geometry
0   Staten Island   1.623820e+09    MULTIPOLYGON (((970217.022 145643.332, ....
1   Queens          3.045213e+09    MULTIPOLYGON (((1029606.077 156073.814, ...
2   Brooklyn        1.937479e+09    MULTIPOLYGON (((1021176.479 151374.797, ...
3   Manhattan       6.364715e+08    MULTIPOLYGON (((981219.056 188655.316, ....
4   Bronx           1.186925e+09    MULTIPOLYGON (((1012821.806 229228.265, ...
>>> type(nybb)
<class 'geopandas.geodataframe.GeoDataFrame'>
>>> type(nybb["geometry"])
<class 'geopandas.geoseries.GeoSeries'>

nybb is a GeoDataFrame. A GeoDataFrame has rows, columns, and all the methods of a pandas DataFrame. The difference is that it typically includes a special geometry column, which stores geographic shapes instead of plain numbers or text.

The geometry column is a GeoSeries. It behaves like a normal pandas Series, but its values are spatial objects that you can map and run spatial queries against. In the nybb dataset, each borough’s geometry is a MultiPolygon—a shape made of several polygons—because every borough consists of multiple islands. Soon you’ll use these geometries to make maps and run spatial operations, such as finding which borough a point falls inside.

Mapping Data

Once you’ve loaded a GeoDataFrame, one of the quickest ways to understand your data is to visualize it. In this section, you’ll learn how to create both static and interactive maps. This allows you to inspect shapes, spot patterns, and confirm that your geometries look the way you expect.

Creating Static Maps

Read the full article at https://realpython.com/geopandas/ »

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

Quiz: GeoPandas Basics: Maps, Projections, and Spatial Joins

2026-01-26T12:00:00+00:00

In this quiz, you’ll test your understanding of GeoPandas.

You’ll review coordinate reference systems, GeoDataFrames, interactive maps, and spatial joins with .sjoin(). You’ll also explore how projections affect maps and learn best practices for working with geospatial data.

This quiz helps you confirm that you can prepare, visualize, and analyze geospatial data accurately using GeoPandas.

[ 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 #281: Continuing to Improve the Learning Experience at Real Python

2026-01-23T12:00:00+00:00

If you haven't visited the Real Python website lately, then it's time to check out a great batch of updates on realpython.com! Dan Bader returns to the show this week to discuss improvements to the site and more ways to learn 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 ]

How to Integrate Local LLMs With Ollama and Python

2026-01-21T14:00:00+00:00

Integrating local large language models (LLMs) into your Python projects using Ollama is a great strategy for improving privacy, reducing costs, and building offline-capable AI-powered apps.

Ollama is an open-source platform that makes it straightforward to run modern LLMs locally on your machine. Once you’ve set up Ollama and pulled the models you want to use, you can connect to them from Python using the ollama library.

Here’s a quick demo:

In this tutorial, you’ll integrate local LLMs into your Python projects using the Ollama platform and its Python SDK.

You’ll first set up Ollama and pull a couple of LLMs. Then, you’ll learn how to use chat, text generation, and tool calling from your Python code. These skills will enable you to build AI-powered apps that run locally, improving privacy and cost efficiency.

Get Your Code: Click here to download the free sample code that you’ll use to integrate LLMs With Ollama and Python.

Take the Quiz: Test your knowledge with our interactive “How to Integrate Local LLMs With Ollama and Python” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Integrate Local LLMs With Ollama and Python

Check your understanding of using Ollama with Python to run local LLMs, generate text, chat, and call tools for private, offline apps.

Prerequisites

To work through this tutorial, you’ll need the following resources and setup:

Ollama installed and running: You’ll need Ollama to use local LLMs. You’ll get to install it and set it up in the next section.
Python 3.8 or higher: You’ll be using Ollama’s Python software development kit (SDK), which requires Python 3.8 or higher. If you haven’t already, install Python on your system to fulfill this requirement.
Models to use: You’ll use llama3.2:latest and codellama:latest in this tutorial. You’ll download them in the next section.
Capable hardware: You need relatively powerful hardware to run Ollama’s models locally, as they may require considerable resources, including memory, disk space, and CPU power. You may not need a GPU for this tutorial, but local models will run much faster if you have one.

With these prerequisites in place, you’re ready to connect local models to your Python code using Ollama.

Step 1: Set Up Ollama, Models, and the Python SDK

Before you can talk to a local model from Python, you need Ollama running and at least one model downloaded. In this step, you’ll install Ollama, start its background service, and pull the models you’ll use throughout the tutorial.

Get Ollama Running

To get started, navigate to Ollama’s download page and grab the installer for your current operating system. You’ll find installers for Windows 10 or newer and macOS 14 Sonoma or newer. Run the appropriate installer and follow the on-screen instructions. For Linux users, the installation process differs slightly, as you’ll learn soon.

On Windows, Ollama will run in the background after installation, and the CLI will be available for you. If this doesn’t happen automatically for you, then go to the Start menu, search for Ollama, and run the app.

On macOS, the app manages the CLI and setup details, so you just need to launch Ollama.app.

If you’re on Linux, install Ollama with the following command:

$ curl -fsSL https://ollama.com/install.sh | sh

Once the process is complete, you can verify the installation by running:

$ ollama -v

If this command works, then the installation was successful. Next, start Ollama’s service by running the command below:

$ ollama serve

That’s it! You’re now ready to start using Ollama on your local machine. In some Linux distributions, such as Ubuntu, this final command may not be necessary, as Ollama may start automatically when the installation is complete. In that case, running the command above will result in an error.

Read the full article at https://realpython.com/ollama-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 ]

Quiz: How to Integrate Local LLMs With Ollama and Python

2026-01-21T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Integrate Local LLMs With Ollama and Python.

By working through this quiz, you’ll revisit how to set up Ollama, pull models, and use chat, text generation, and tool calling from Python.

You’ll connect to local models through the ollama Python library and practice sending prompts and handling responses. You’ll also see how local inference can improve privacy and cost efficiency while keeping your apps offline-capable.

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

uv vs pip: Python Packaging and Dependency Management

2026-01-20T14:00:00+00:00

When it comes to Python package managers, the choice often comes down to uv vs pip. You may choose pip for out-of-the-box availability, broad compatibility, and reliable ecosystem support. In contrast, uv is worth considering if you prioritize fast installs, reproducible environments, and clean uninstall behavior, or if you want to streamline workflows for new projects.

In this video course, you’ll compare both tools. To keep this comparison meaningful, you’ll focus on the overlapping features, primarily package installation and dependency management.

[ 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 Integrate ChatGPT's API With Python Projects

2026-01-19T14:00:00+00:00

Python’s openai library provides the tools you need to integrate the ChatGPT API into your Python applications. With it, you can send text prompts to the API and receive AI-generated responses. You can also guide the AI’s behavior with developer role messages and handle both simple text generation and more complex code creation tasks. Here’s an example:

After reading this tutorial, you’ll understand how examples like this work under the hood. You’ll learn the fundamentals of using the ChatGPT API from Python and have code examples you can adapt for your own projects.

Get Your Code: Click here to download the free sample code that you’ll use to integrate ChatGPT’s API with Python projects.

Take the Quiz: Test your knowledge with our interactive “How to Integrate ChatGPT's API With Python Projects” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Integrate ChatGPT's API With Python Projects

Test your knowledge of the ChatGPT API in Python. Practice sending prompts with openai and handling text and code responses in this quick quiz.

Prerequisites

To follow along with this tutorial, you’ll need the following:

Python Knowledge: You should be familiar with Python concepts like functions, executing Python scripts, and Python virtual environments.
Python Installation: You’ll need Python installed on your system. If you haven’t already, install Python on your machine.
OpenAI Account: An OpenAI account with API access and available credits is required to use the ChatGPT API. You’ll obtain your API key from the OpenAI platform in Step 1.

Don’t worry if you’re new to working with APIs. This tutorial will guide you through everything you need to know to get started with the ChatGPT API and implement AI features in your applications.

Step 1: Obtain Your API Key and Install the OpenAI Package

Before you can start making calls to the ChatGPT Python API, you need to obtain an API key and install the OpenAI Python library. You’ll start by getting your API key from the OpenAI platform, then install the required package and verify that everything works.

Obtain Your API Key

You can obtain an API key from the OpenAI platform by following these steps:

Navigate to platform.openai.com and sign in to your account or create a new one if you don’t have an account yet.
Click on the settings icon in the top-right corner and select API keys from the left-hand menu.
Click the Create new secret key button to generate a new API key.
In the dialog that appears, give your key a descriptive name like “Python Tutorial Key” to help you identify it later.
For the Project field, select your preferred project.
Under Permissions, select All to give your key full access to the API for development purposes.
Click Create secret key to generate your API key.
Copy the generated key immediately, as you won’t be able to see it again after closing the dialog.

Now that you have your API key, you need to store it securely.

Warning: Never hard-code your API key directly in your Python scripts or commit it to version control. Always use environment variables or secure key management services to keep your credentials safe.

The OpenAI Python library automatically looks for an environment variable named OPENAI_API_KEY when creating a client connection. By setting this variable in your terminal session, you’ll authenticate your API requests without exposing your key in your code.

Set the OPENAI_API_KEY environment variable in your terminal session:

PS> $env:OPENAI_API_KEY="your-api-key-here"

$ export OPENAI_API_KEY="your-api-key-here"

Replace your-api-key-here with the actual API key you copied from the OpenAI platform.

Install the OpenAI Package

With your API key configured, you can now install the OpenAI Python library. The openai package is available on the Python Package Index (PyPI), and you can install it with pip.

Open a terminal or command prompt, create a new virtual environment, and then install the library:

Read the full article at https://realpython.com/chatgpt-api-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 ]

Quiz: How to Integrate ChatGPT's API With Python Projects

2026-01-19T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Integrate ChatGPT’s API With Python Projects.

By working through this quiz, you’ll revisit how to send prompts with the openai library, guide behavior with developer role messages, and handle text and code outputs. You’ll also see how to integrate AI responses into your Python scripts for practical tasks.

[ 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 #280: Considering Fast and Slow in Python Programming

2026-01-16T12:00:00+00:00

How often have you heard about the speed of Python? What's actually being measured, where are the bottlenecks---development time or run time---and which matters more for productivity? Christopher Trudeau is back on the show this week, bringing 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 ]

How to Create a Django Project

2026-01-14T14:00:00+00:00

Before you can start building your Django web application, you need to set up your Django project. In this guide you’ll learn how to create a new Django project in four straightforward steps and only six commands:

Step	Description	Command
1a	Set up a virtual environment	`python -m venv .venv`
1b	Activate the virtual environment	`source .venv/bin/activate`
2a	Install Django	`python -m pip install django`
2b	Pin your dependencies	`python -m pip freeze > requirements.txt`
3	Set up a Django project	`django-admin startproject <projectname>`
4	Start a Django app	`python manage.py startapp <appname>`

The tutorial focuses on the initial steps you’ll always need to start a new web application.

Use this tutorial as your go-to reference until you’ve built so many projects that the necessary commands become second nature. Until then, follow the steps outlined below and in the command reference, or download the PDF cheatsheet as a printable reference:

Free Bonus: Click here to download the Django Project cheat sheet that assembles all important commands and tips on one page that’s easy to print.

There are also a few exercises throughout the tutorial to help reinforce what you’re learning, and you can test your knowledge in the associated quiz:

Take the Quiz: Test your knowledge with our interactive “How to Create a Django Project” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Create a Django Project

Check your Django setup skills. Install safely and pin requirements, create a project and an app. Start building your first site.

Get Your Code: Click here to download the free sample code that shows you how to create a Django project.

Prerequisites

Before you start creating your Django project, make sure you have the right tools and knowledge in place. This tutorial assumes you’re comfortable working with the command line, but you don’t need to be an expert. Here’s what you’ll need to get started:

Python 3.12 or higher installed on your system
Basic familiarity with virtual environments
Understanding of Python’s package manager, pip
Access to a command-line interface

You don’t need any prior Django experience to complete this guide. However, to build functionality beyond the basic scaffolding, you’ll need to know Python basics and at least some Django.

Step 1: Prepare Your Environment

When you’re ready to start your new Django web application, create a new folder and navigate into it. In this folder, you’ll set up a new virtual environment using your terminal:

PS> python -m venv .venv

$ python3 -m venv .venv

This command sets up a new virtual environment named .venv in your current working directory. Once the process is complete, you also need to activate the virtual environment:

PS> .venv\Scripts\activate

$ source .venv/bin/activate

If the activation was successful, then you’ll see the name of your virtual environment, (.venv), at the beginning of your command prompt. This means that your environment setup is complete.

You can learn more about how to work with virtual environments in Python, and how to perfect your Python development setup, but for your Django setup, you have all you need. You can continue with installing the django package.

Step 2: Install Django and Pin Your Dependencies

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

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

Quiz: How to Create a Django Project

2026-01-14T12:00:00+00:00

In this quiz, you’ll test your understanding of creating a Django project.

By working through this quiz, you’ll revisit how to create and activate a virtual environment, install Django and pin your dependencies, start a Django project, and start a Django app. You will also see how isolating dependencies helps others reproduce your setup.

To revisit and keep learning, watch the video course on How to Set Up a Django Project.

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

Intro to Object-Oriented Programming (OOP) in Python

2026-01-13T14:00:00+00:00

Object-oriented programming (OOP) is one of the most significant and essential topics in programming. This course will give you a foundational conceptual understanding of object-oriented programming to help you elevate your Python skills.

You’ll learn how to define custom types using classes and how to instantiate those classes into Python objects that can be used throughout your program.

Finally, you’ll discover how classes can inherit from one another, with a brief introduction to inheritance, enabling you to write maintainable and less redundant Python 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 ]

Python's deque: Implement Efficient Queues and Stacks

2026-01-12T14:00:00+00:00

You can use Python’s deque for efficient appends and pops at both ends of a sequence-like data type. These capabilities are critical when you need to implement queue and stack data structures that operate efficiently even under heavy workloads.

In this tutorial, you’ll learn how deque works, when to use it over a list, and how to apply it in real code.

By the end of this tutorial, you’ll understand that:

deque internally uses a doubly linked list, so end operations are O(1) while random indexing is O(n).
You can build a FIFO queue with .append() and .popleft(), and a LIFO stack with .append() and .pop().
deque supports indexing but doesn’t support slicing.
Passing a value to maxlen creates a bounded deque that drops items from the opposite end when full.
In CPython, .append(), .appendleft(), .pop(), .popleft(), and len() are thread-safe for multithreaded use.

Up next, you’ll get started with deque, benchmark it against list, and explore how it shines in real-world use cases, such as queues, stacks, history buffers, and thread-safe producer-consumer setups.

Get Your Code: Click here to download the free sample code that shows you how to implement efficient queues and stacks with Python’s deque.

Take the Quiz: Test your knowledge with our interactive “Python's deque: Implement Efficient Queues and Stacks” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python's deque: Implement Efficient Queues and Stacks

Use Python's deque for fast queues and stacks. Refresh end operations, maxlen rollover, indexing limits, and thread-safe methods.

Get Started With Python’s `deque`

Appending to and popping from the right end of a Python list are efficient operations most of the time. Using the Big O notation for time complexity, these operations are O(1). However, when Python needs to reallocate memory to grow the underlying list to accept new items, these operations slow down and can become O(n).

In contrast, appending and popping items from the left end of a Python list are always inefficient and have O(n) time complexity.

Because Python lists provide both operations with the .append() and .pop() methods, you can use them as stacks and queues. However, the performance issues you saw before can significantly impact the overall performance of your applications.

Python’s deque was the first data type added to the collections module back in Python 2.4. This data type was specially designed to overcome the efficiency problems of .append() and .pop() in Python lists.

A deque is a sequence-like data structure designed as a generalization of stacks and queues. It supports memory-efficient and fast append and pop operations on both ends.

Note: The word deque is pronounced as “deck.” The name stands for double-ended queue.

Append and pop operations on both ends of a deque object are stable and equally efficient because deques are implemented as a doubly linked list. Additionally, append and pop operations on deques are thread-safe and memory-efficient. These features make deques particularly useful for creating custom stacks and queues in Python.

Deques are also a good choice when you need to keep a list of recently seen items, as you can restrict the maximum length of your deque. By setting a maximum length, once a deque is full, it automatically discards items from one end when you append new items to the opposite end.

Here’s a summary of the main features of deque:

Stores items of any data type
Is a mutable data type
Supports membership operations with the in operator
Supports indexing, like in a_deque[i]
Doesn’t support slicing, like in a_deque[0:2]
Supports built-in functions that operate on sequences and iterables, such as len(), sorted(), reversed(), and more
Doesn’t support in-place sorting
Supports normal and reverse iteration
Supports pickling with pickle
Supports fast, memory-efficient, and thread-safe pop and append operations on both ends

To create deques, you just need to import deque from collections and call it with an optional iterable as an argument:

>>> from collections import deque

>>> # Create an empty deque
>>> deque()
deque([])

>>> # Use different iterables to create deques
>>> deque((1, 2, 3, 4))
deque([1, 2, 3, 4])

>>> deque([1, 2, 3, 4])
deque([1, 2, 3, 4])

>>> deque(range(1, 5))
deque([1, 2, 3, 4])

>>> deque("abcd")
deque(['a', 'b', 'c', 'd'])

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> deque(numbers.keys())
deque(['one', 'two', 'three', 'four'])

>>> deque(numbers.values())
deque([1, 2, 3, 4])

>>> deque(numbers.items())
deque([('one', 1), ('two', 2), ('three', 3), ('four', 4)])

If you instantiate deque without providing an iterable as an argument, then you get an empty deque. If you provide an iterable, then deque initializes the new instance with data from it. The initialization goes from left to right using deque.append().

The deque initializer takes the following two optional arguments:

iterable holds an iterable that provides the initialization data.
maxlen holds an integer number that specifies the maximum length of the deque.

As mentioned previously, if you don’t supply an iterable, then you get an empty deque. If you provide a value to maxlen, then your deque will only store up to maxlen items.

Finally, you can also use unordered iterables, such as sets, to initialize your deques. In those cases, you won’t have a predefined order for the items in the final deque.

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

[ 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 #279: Coding Python With Confidence: Beginners Live Course Participants

2026-01-09T12:00:00+00:00

Are you looking for that solid foundation to begin your Python journey? Would the accountability of scheduled group classes help you get through the basics and start building something? This week, two members of the Python for Beginners live course discuss their experiences.

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

Tips for Using the AI Coding Editor Cursor

2026-01-06T14:00:00+00:00

Cursor is an AI-powered integrated development environment (IDE) based on the Visual Studio Code codebase. It comes with a multi-agent interface and the Composer model for fast, agentic coding while keeping a familiar editor workflow with project-aware chat, code completion, and inline edits.

In this course, you will:

Understand why Cursor might work for you
Learn how to use different modes & models
See how to run multiple agents at a time
Resolve a tiny merge conflict
Run a project and fix a bug
Learn commands and practice with the terminal

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

Quiz: How to Properly Indent Python Code

2026-01-05T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Indent in Python.

By working through this quiz, you’ll revisit how to properly indent Python code, choose helpful editor settings, use spaces properly, apply code formatters, and explain why indentation is required.

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

Quiz: How to Convert Bytes to Strings in Python

2026-01-05T12:00:00+00:00

In this quiz, you’ll test your understanding of the Convert Python Bytes to Strings tutorial.

By working through this quiz, you’ll revisit how to decode bytes, choose an encoding, and turn binary data into readable text.

You’ll also see how encodings map byte values to characters so you can handle data from files, databases, and APIs with confidence. For a deeper dive, check out Python Encodings: A Guide and Python Bytes.

[ 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 #278: PyCoder's Weekly 2025 Top Articles & Hidden Gems

2026-01-02T12:00:00+00:00

PyCoder's Weekly included over 1,500 links to articles, blog posts, tutorials, and projects in 2025. Christopher Trudeau is back on the show this week to help wrap up everything by sharing some highlights and uncovering a few hidden gems from the pile.

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

Quiz: LlamaIndex in Python: A RAG Guide With Examples

2025-12-24T12:00:00+00:00

In this quiz, you’ll test your understanding of the LlamaIndex in Python: A RAG Guide With Examples tutorial.

By working through this quiz, you’ll revisit how to create and persist an index to disk, review how to reload it, and see why persistence improves performance, lowers costs, saves time, and keeps results consistent.

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

Reading User Input From the Keyboard With Python

2025-12-23T14:00:00+00:00

You may often want to make your Python programs more interactive by responding dynamically to input from the user. Learning how to read user input from the keyboard unlocks exciting possibilities and can make your code far more useful.

The ability to gather input from the keyboard with Python allows you to build programs that can respond uniquely based on the preferences, decisions, or data provided by different users. By fetching input and assigning it to variables, your code can react to adjustable conditions rather than just executing static logic flows. This personalizes programs to individual users.

The input() function is the simplest way to get keyboard data from the user in Python. When called, it asks the user for input with a prompt that you specify, and it waits for the user to type a response and press the Enter key before continuing. This response string is returned by input() so you can save it to a variable or use it directly.

Using only Python, you can start building interactive programs that accept customizable data from the user right within the terminal. Taking user input is an essential skill that unlocks more dynamic Python coding and allows you to elevate simple scripts into personalized applications.

[ 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 #277: Moving Towards Spec-Driven Development

2025-12-19T12:00:00+00:00

What are the advantages of spec-driven development compared to vibe coding with an LLM? Are these recent trends a move toward declarative programming? This week on the show, Marc Brooker, VP and Distinguished Engineer at AWS, joins us to discuss specification-driven development and Kiro.

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

Exploring Asynchronous Iterators and Iterables

2025-12-16T14:00:00+00:00

When you write asynchronous code in Python, you’ll likely need to create asynchronous iterators and iterables at some point. Asynchronous iterators are what Python uses to control async for loops, while asynchronous iterables are objects that you can iterate over using async for loops.

Both tools allow you to iterate over awaitable objects without blocking your code. This way, you can perform different tasks asynchronously.

In this video course, you’ll:

Learn what async iterators and iterables are in Python
Create async generator expressions and generator iterators
Code async iterators and iterables with the .__aiter__() and .__anext__() methods
Use async iterators in async loops and comprehensions

[ 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 Functional Programming in Python

2025-12-09T14:00:00+00:00

Functional programming is a programming paradigm in which the primary method of computation is the evaluation of functions. But how does Python support functional programming?

In this video course, you’ll learn:

What the functional programming paradigm entails
What it means to say that functions are first-class citizens in Python
How to define anonymous functions with the lambda keyword
How to implement functional code using map(), filter(), and reduce()

[ 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 #276: Exploring Quantum Computing & Python Frameworks

2025-12-05T12:00:00+00:00

What are the recent advances in the field of quantum computing and high-performance computing? And what Python tools can you use to develop programs that run on quantum computers? This week on the show, Real Python author Negar Vahid discusses her tutorial, "Quantum Computing Basics With Qiskit."

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

Introduction to pandas

2025-12-02T14:00:00+00:00

The pandas DataFrame is a structure that contains two-dimensional data and its corresponding labels. DataFrames are widely used in data science, machine learning, scientific computing, and many other data-intensive fields.

DataFrames are similar to SQL tables or the spreadsheets that you work with in Excel or Calc. In many cases, DataFrames are faster, easier to use, and more powerful than tables or spreadsheets because they’re an integral part of the Python and NumPy ecosystems.

In this video course, you’ll learn:

What a pandas DataFrame is and how to create one
How to access, modify, add, sort, filter, and delete data
How to handle missing values
How to work with time-series data
How to quickly visualize 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 ]

The Real Python Podcast – Episode #275: Building a FastAPI Application & Exploring Python Concurrency

2025-11-21T12:00:00+00:00

What are the steps to get started building a FastAPI application? What are the different types of concurrency available in Python? Christopher Trudeau is back on the show this week, bringing 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 ]

Real Python

The Real Python Podcast – Episode #284: Running Local LLMs With Ollama and Connecting With Python

Quiz: Python's list Data Type: A Deep Dive With Examples

What Exactly Is the Zen of Python?

In Short: It’s a Humorous Poem Listing Python Philosophies

How Did the Zen of Python Originate?

Should You Obey the Zen of Python?

Quiz: What Exactly Is the Zen of Python?

Improving Your Tests With the Python Mock Object Library

Quiz: Python's pathlib Module: Taming the File System

pandas 3.0 Lands Breaking Changes and Other Python News for February 2026

Python Releases and PEP Highlights

Python 3.15.0 Alpha 4 and 5: Two Releases in Two Days

PEP 822 Drafted: Dedented Multiline Strings (d-strings)

PSF News: Investments, Fellows, and Survey

Anthropic Invests in Python Security

The Real Python Podcast – Episode #283: Improving Your GitHub Developer Experience

Why You Should Attend a Python Conference

Prerequisites

Understand What Python Conferences Actually Offer

Personal Growth

Community Involvement

Getting Started With Google Gemini CLI

The Terminal: First Steps and Useful Commands for Python Developers

Install and Open the Terminal

Windows

Linux

macOS

The Real Python Podcast – Episode #282: Testing Python Code for Scalability & What's New in pandas 3.0

How Long Does It Take to Learn Python?

How Long Does It Take to Learn Python Basics?

What’s a Practical 30-Day Learning Plan for Complete Beginners?

Create Callable Instances With Python's .__call__()

GeoPandas Basics: Maps, Projections, and Spatial Joins

Getting Started With GeoPandas

Installing GeoPandas

Reading in Data

Mapping Data

Creating Static Maps

Quiz: GeoPandas Basics: Maps, Projections, and Spatial Joins

The Real Python Podcast – Episode #281: Continuing to Improve the Learning Experience at Real Python

How to Integrate Local LLMs With Ollama and Python

Prerequisites

Step 1: Set Up Ollama, Models, and the Python SDK

Get Ollama Running

Quiz: How to Integrate Local LLMs With Ollama and Python

uv vs pip: Python Packaging and Dependency Management

How to Integrate ChatGPT's API With Python Projects

Prerequisites

Step 1: Obtain Your API Key and Install the OpenAI Package

Obtain Your API Key

Install the OpenAI Package

Quiz: How to Integrate ChatGPT's API With Python Projects

The Real Python Podcast – Episode #280: Considering Fast and Slow in Python Programming

How to Create a Django Project

Prerequisites

Step 1: Prepare Your Environment

Step 2: Install Django and Pin Your Dependencies

Quiz: How to Create a Django Project

Intro to Object-Oriented Programming (OOP) in Python

Python's deque: Implement Efficient Queues and Stacks

Get Started With Python’s deque

The Real Python Podcast – Episode #279: Coding Python With Confidence: Beginners Live Course Participants

Tips for Using the AI Coding Editor Cursor

Quiz: How to Properly Indent Python Code

Quiz: How to Convert Bytes to Strings in Python

The Real Python Podcast – Episode #278: PyCoder's Weekly 2025 Top Articles & Hidden Gems

Quiz: LlamaIndex in Python: A RAG Guide With Examples

Reading User Input From the Keyboard With Python

The Real Python Podcast – Episode #277: Moving Towards Spec-Driven Development

Exploring Asynchronous Iterators and Iterables

Using Functional Programming in Python

The Real Python Podcast – Episode #276: Exploring Quantum Computing & Python Frameworks

Introduction to pandas

The Real Python Podcast – Episode #275: Building a FastAPI Application & Exploring Python Concurrency

Create Callable Instances With Python's .call()

Get Started With Python’s `deque`