#100DaysCode for Python Web Apps: Flask, Django, and More Course

Course Summary

#100DaysOfWeb in Python is a course that will ensure your success with the 100 days of code challenge, all while teaching you Python web development. With every 4 days dedicated to a different concept, you’ll be amazed at how many Python Web technologies and libraries you’ll learn on this journey. Join the course and start your 100 day challenge now.

What students are saying

Day 100, #100DaysOfCode progress: Today I completed the 100 Days of Web in #Python course! I learned SO much and can't thank Talk Python enough! #finished
-- Ryan (@ryancheley)

Source code and course GitHub repository

github.com/talkpython/100daysofweb-with-python-course

What's this course about and how is it different?

100 days of code isn’t just about the time commitment. The true power is in utilising that time effectively with a tailored set of projects. That’s why we have 24 practical projects, each paired with 20-60 minute video lessons at the beginning of the project.

Just a small sampling of the projects you’ll work on include:

  • Create your very own Static Site
  • Use FastAPI to build an API that automatically converts and validates data
  • An introduction to the Flask framework
  • Learn Javascript by making a calculator and calorie counter
  • SQLAlchemy Database creation
  • Use Docker to containerize your applications
  • Build a Bill Tracking web tool with Pyramid
  • Use React to build Javascript user interfaces
  • Selenium testing of numerous web functions
  • Django app creation with registration and login functionality
  • Web Scraping with BeautifulSoup4 and newspaper3k
  • And 17 more projects!

View the full course outline.

Who is this course for?

This course is for anyone who knows the basics of Python and wants to push themselves into the world of Python Web Development for 100 days with hands-on projects.

We don’t start from absolute zero in terms of programming but if you are new to Python we have a language appendix and we start somewhat slow. By the end of the course, we get into intermediate-level Python projects.

Course flow and the 28 projects

This course is 2-part video lessons and 2-parts hands-on exercises.

Course flow

We have broken the 100 days worth of coding into 24 4-day segments. As you can see, the first day is largely learning the new topics (Flask, HTML, CSS, etc). The following two to three days have some guidance but are much more hands-on than the first day.

Hands-on exercises for almost every chapter

#100DaysOfCode is literally about doing some coding every day. That's why this course has practical hands-on exercises for every single one of the 100 days.

These exercises range in length from 10 minutes to about 1-hour a day. Here is the readme introducing a 4-day project for the Docker chapter.

Here is the 4-day project for the Docker chapter.

Hands on exercises

Concepts backed by concise visuals

While exploring a topic interactively with demos and live code is very engaging, it can lose the forest for the trees. That's why when we hit a new topic, we stop and discuss it with concise and clear visuals.

Here's an example of how we review the concept of creating database definitions with SQLAlchemy for the purposes of Flask-Login.

Example: Concepts backed by concise visuals

You might also like our other #100DaysOfCode course

If you'd rather start at the learning Python level rather than jumping straight into Python web development, check out our other course: #100DaysOfCode in Python.

#100DaysOfWeb in Python course

Follow along with subtitles and transcripts

Each course comes with subtitles and full transcripts. The transcripts are available as a separate searchable page for each lecture. They also are available in course-wide search results to help you find just the right lecture.

Each course has subtitles available in the video player.

Who we are and why should you take our course?

Meet Michael Kennedy:

Who is Michael Kennedy?

My name is Michael, nice to meet you. ;) There are a couple of reasons I'm especially qualified to teach you Python.

 1. I'm the host of the #1 podcast on Python called Talk Python To Me. Over there, I've interviewed many of the leaders and creators in the Python community. I bring that perspective to all the courses I create.

 2. I've been a professional software trainer for over 10 years. I have taught literally thousands of professional developers in hundreds of courses throughout the world.

 3. Students have loved my courses. Here are just a few quotes from past students of mine.

"Michael is super knowledgeable, loves his craft, and he conveys it all well. I would highly recommend his training class anytime." - Robert F.
"Michael is simply an outstanding instructor." - Kevin R.
"Michael was an encyclopedia for the deep inner workings of Python. Very impressive." - Neal L.

Meet Bob Belderbos:

Who is Bob Belderbos?

Hey there, my name is Bob Belderbos, a passionate Pythonista and software developer. Thanks for considering this course. It's aim is to make you a well rounded Python developer. For some it might even be a career changer.

I am excited to teach you this course for several reasons:

  1. During my 10+ years of programming I have come to know how immensely gratifying it is to build software to make somebody else's (or my own) life easier. I can only wish for you to experience the same once you gain the necessary skills.
  2. I have grown from a support engineer and self-taught website creator into a full-time software developer at Oracle, a career switch that makes me wake up every day energized and hungry to expand my knowledge and skills (sometimes challenging but surely exciting). Do you want to upgrade your job or even switch your career? This course will give you a solid foundation to draw from.
  3. Since co-founding PyBites end of 2016 I made great strides in my Python skills. We published many challenges and articles and built a Code Challenge platform from scratch. We have a growing community of passionate Pythonistas that are improving their Python skills with us. We love to share/teach our learning and mentor other developers.

I am both honored and stoked to teach you Python using this 100 Days format. We did it ourselves and we know it works. The hard work won't go away but we can definitely make it easier, more accessible and fun!

Meet Julian Sequeira:

Who is Julian Sequeira?

G'day! I'm Julian Sequeira, a self-taught Python fan(atic) and a #100daysofcode survivor.

It's safe to say that the 100 days of code challenge was instrumental in pushing my Python skills to the next level.

This is why I'm so excited to work with and guide you through the process!

The diversity in the code and concepts you'll be exposed to in this course is staggering. It may seem like a lot but it ensures you'll stay interested and motivated to get through to the highly coveted Day 100.

When I'm not working in my AWS Data Center keeping the Cloud up and running, you'll find me in two places:

  1. Writing articles on Python, contributing to and running PyBites with co-founder Bob. This site is a labour of love and the core motivator for me to keep learning more Python. It's my baby!
  2. Teaching on Udemy! My Python Flask introductory course has been incredibly well received by my students. If you didn't know, I have a not-so-secret love affair with Flask so this is just icing on the cake.

Cheers to your 100 Days of Code in Python journey!

Free office hours keep you from getting stuck

One of the challenges of self-paced online learning is getting stuck. It can be hard to get the help you need to get unstuck.

That's why at Talk Python Training, we offer live, online office hours. You drop in and join a group of fellow students to chat about your course progress and see solutions via screen sharing.

Just visit your account page to see the upcoming office hour schedule.

Is this course based on Python 3 or Python 2?

This course is based upon Python 3. Python 2 is officially unsupported as of January 1st, 2020 and we believe that it would be ill-advised to teach or learn Python 2. This course is, and has always been, built around Python 3.

The time to act is now

The #100DaysOfCode challenge is an epic adventure. Don't got it alone. Take our course and we'll be your guide with both lessons and projects.

Course Outline: Chapters and Lectures

Welcome to the course
26:58
Welcome to the course
2:38
The rules of #100DaysOfCode
1:01
Topics covered
3:48
Why Python for #100DaysOfCode
2:02
Course flow
2:20
Meet your instructors
1:30
Need a Python primer?
1:10
Git the source code
2:13
Three devs are better than one
1:29
Julian's setup
0:34
Bob's setup
0:35
Michael's setup
2:45
PyBites code challenge platform
2:48
Video player: A quick feature tour
2:05
Days 1-4: Flask Intro
47:20
Introduction to Flask
0:59
Your Next 4 Days
2:15
Install and Setup Flask
3:39
Setup your Flask app as a package
2:57
Create __init.py__
2:33
Define your Flask app routes in routes.py
3:10
Run your Flask app!
3:41
Persistent FLASK_APP environment variable using python-dotenv
3:03
Creating a basic index.html Flask Template
4:52
Creating the base.html Flask Template
7:19
A new template for a 100DaysOfCode page
4:30
Using CSS, create Menu Bar in the Base Template
3:25
Day 4: Your Turn - What did we learn?
4:57
Days 5-8: HTML and HTML5
37:49
HTML Chapter Intro
1:05
HTML is easy right?
1:42
A little HTML history
3:41
Our editor for this chapter: WebStorm
0:50
Yahoo, circa 1996
1:15
Building Yaahoo
12:21
Concept: Core HTML tags
2:41
Form basics
3:40
Describing form elements
2:55
Client-side validation
5:36
Your-turn
2:03
Days 9-12: FastAPI
32:03
Lesson introduction
1:05
Introducing our first API
0:50
Project setup
3:49
The most basic API
5:17
Concept: A minimal API endpoint
0:45
Know your HTTP verbs
3:09
Know your HTTP status codes
2:14
Passing data to the API
2:59
Concept: Passing data to the API
1:12
Responding to requests
5:33
Using specialized responses
1:28
Concept: Returning errors
1:22
A home page of sorts
2:20
Days 13-16: CSS Layout and Design
47:26
CSS chapter intro
1:22
Goals of this chapter
3:38
CSS Zen Garden
4:12
Concept: Structure of a CSS file
3:50
Demo app introduction
1:19
Demo: Exploring CSS selectors
4:13
Concept: Inheritance and specialization
1:55
Demo: Box model
4:17
Concept: Controlling the box in CSS
1:11
Demo: Layout
7:19
Demo: Floating elements
4:02
Concept: Floating elements
0:58
Areas to research further
4:02
Your-turn: Day 2
1:07
Your-turn: Day 3
2:20
Your-turn: Day 4
1:41
Days 17-20: Calling APIs in Flask
59:31
Introduction: Calling APIs in Flask
0:34
Your 4 day overview
2:28
Environment setup
4:38
Passing variables between Flask app code and a Template
7:10
Working with the Chuck Norris API
4:16
Passing our Chuck Norris joke to a Template
5:30
Investigating the Poke API
1:35
Creating a form in our Pokemon Template
8:16
Breaking down the Poke API response
6:46
Writing the Pokemon route
7:10
Returning the data to the Pokemon Template
6:56
Day 4: Your Turn - What did we learn?
4:12
Days 21-24: Async Flask APIs with Quart
55:09
Introducing asynchronous web programming
2:02
Synchronous execution concepts
4:34
Synchronous execution demo
6:16
Asynchronous Python execution with async and await
9:09
Asynchronous execution concepts
2:24
Your turn: Day 2 - Async program
2:43
Flask will never be async capable
2:08
Introducing our web app: The cityscape API
7:11
Converting from Flask to Quart
2:58
Adding an async view method / controller method
5:11
Async all the things
2:34
Concept: Quart
2:09
Performance comparison: Flask vs Quart
4:08
Your turn: Day 4 - Async Flask conversion
1:42
Days 25-28: JavaScript Introduction
1:14:31
Lesson introduction
0:48
4 day plan
2:51
History and why JavaScript
3:16
How to run JS in your browser / terminal / IDE
4:23
Variables (var vs let) and data types
5:27
Arrays
4:50
Conditionals and control flow
5:54
Functions
9:18
Objects
3:53
Day 2: 4 JS exercises
3:10
The Document Object Model (DOM) - targeting elements
8:03
DOM part II: add/remove childs, override CSS, event listeners
8:58
Debugging JavaScript
2:54
Common JS gotchas
3:30
Further study
3:08
Day 4: simple calculator and calorie tracker
4:08
Days 29-32: Static Sites
45:19
Introduction: Static Sites
0:36
Your 4 day overview
2:00
What exactly is a static site anyway?
4:52
Setup: Create your repo
1:45
Configure Pelican
4:45
Writing our first post!
6:48
Generating the site
3:48
Setting up and deploying to Netlify
5:11
Linking to static content
4:30
How sweet is Netlify auto-build?
2:22
Creating a dedicated static page
3:48
Custom domains on Netlify
1:35
What did we learn?
3:19
Days 33-36: Database access with SQLAlchemy
1:01:01
Introducing SQLAlchemy
4:07
Our demo app: A scooter sharing startup
1:46
Who uses SQLAlchemy?
1:35
SQLAlchemy Architecture
2:10
Scooter share data model
1:12
Setting up our app
3:38
Modeling with classes
5:41
The rest of the classes
3:33
Connecting to our DB
3:58
Creating the database schema and tables
3:28
The database is created
2:36
Relationships
4:24
Inserts
6:01
The rest of the queries
4:38
Importing starter data
2:04
Finishing the app
6:32
Listen to the interview
0:22
Your turn: Days 3 and 4
3:16
Days 37-40: Introduction to Pyramid framework
1:08:50
Pyramid chapter intro
1:34
Our demo application
1:57
A spectrum of frameworks
2:28
Pyramid principles
2:57
Get back story
0:24
Creating the app: Intro
2:16
Creating the app: Via the CLI
6:31
Creating the app: Via PyCharm
2:45
A tour of a Pyramid project
4:31
Reorganizing our app
4:28
Adding the data models
4:35
Home page (fake data)
4:04
Home page (database data)
6:52
HTML towards details and a better design
1:42
Design and hero images
3:00
Adding the details route
6:07
Paying a bill: Submitting forms
5:49
Concept: Chameleon
2:51
Your-turn: Day 3
3:14
Your-turn: Day 4
0:45
Days 41-44: React: JavaScript user interfaces
1:25:30
Intro: what is React, why use it?
2:10
Brushing up some ES6 (modern) JS
7:38
Bootstrap our app with create-react-app
4:20
JSX and rendering a tip component
6:49
Interlude: Python Tips API back-end setup
2:43
Using classes and state in React
5:46
Calling the tips API using axios
8:06
Filter tips while typing in a search field
4:40
Style matching tips with react-highlight-words
4:40
Day 2: build your own API front-end using React
0:59
Structuring our Free Monkey (hangman) app
7:00
Constructor, componentDidMount, and first render
2:52
Setting the initial game state
5:18
Creating letter buttons with event handlers
3:15
Matching guess letters and updating the state
6:06
Adding CSS styles to the buttons upon guessing
2:32
Check win/loss scenarios, adding a reset game button
8:05
Day 4: build your own game using React
2:31
Days 45-48: Build a simple Django app
1:26:48
Lesson introduction
0:30
The structure of this 4 day module
1:28
Django starter and architecture
3:42
Demo quote CRUD app we will build
1:54
Get Django up and running
3:00
Basic Django configuration
4:10
URL routing and your first view
5:17
Create a Django model and migrate it to the DB
4:21
Playing with the ORM in Django's shell
6:27
Day 2: practice yourself
1:19
The quotes app url mapping
6:16
Create a Django form
1:58
Write a view to list all the quotes
2:48
Static files and the base template
4:54
Template settings and create a child template
6:40
Make a view/page to view an individual quote
3:59
Write a view to add a new quote
6:44
Write a view to edit a quote
2:57
Write a view to delete a quote
4:06
Refactor function-based into class-based views
9:38
Add the quotes app to Django's admin interface
3:10
Day 4: practice yourself
1:30
Day 49: Selenium
43:49
Lesson introduction
1:17
Virtual environment, dependencies, pytest starter code (fixtures)
6:00
Selenium's find_element_by methods, test #1: homepage
6:58
Test #2: testing individual book pages and JS autocomplete
8:07
Test #3: testing the login, using the debugger with pytest
6:19
Test #4: a test function for adding/deleting a book
9:45
Test #5: testing changing nav links upon logout
4:16
Optional Code Challenge: test a simple Django app
1:07
Day 50: Responder framework
28:58
Introducing responder
0:49
Key features
2:10
Foundational projects
0:48
What API will we build?
1:07
Setting up the project
1:44
Adding the 'hello world' view method
1:46
Using dynamic HTML templates (Jinja2)
2:25
Serving static files
1:35
API view methods
2:51
Adding a data backend
3:03
Implementing the search APIs
4:11
Cleanup and refactoring for real web apps
4:28
Responder core concepts
2:01
Day 51: Twilio
15:39
Introduction: Twilio
0:54
Your single day overview
1:49
Twilio account setup
2:59
Obtaining your Twilio API key
1:07
Write a quick and easy Twilio SMS script
4:40
Twilio UI: Verified numbers and usage stats
2:13
What did we learn?
1:57
Day 52: Anvil - Full Stack Web Apps
58:11
Chapter intro
0:42
What is full stack web development?
2:06
What application will we build?
1:00
Introducing Anvil
0:54
Anvil's building blocks
2:42
Anvil: New project
2:09
Adding navigation
2:28
Subforms
2:06
Linking the forms
4:20
Building the add document form
2:08
Add new document validation
4:44
Data tables
2:32
Server-side code
3:26
Creating the document in the database
2:53
Add doc form finale
4:52
All docs form
6:55
Adding filtering to all docs form
1:32
Adding filtering (continued)
3:04
Viewing document details
2:48
Publishing our Anvil app on the Internet
1:55
Concepts of Anvil
2:55
Days 53-56: Django part 2 - registration and login
48:54
Lesson introduction
1:14
The structure of this 4 day module
5:16
Installing and configuring django-registration
4:56
Setting up urls.py for the two-step activation workflow
2:58
Setting required django-registration templates
4:38
Setting up a SendGrid account
1:20
Django SMTP configuration and testing out email
7:21
Adding login and logout links to the navigation bar
5:00
Update the Quote model to associate quotes with users
3:29
Update templates to only show edit buttons to quote owners
6:30
Protecting views with Django's @login_required decorator
4:48
Day 3 + 4: practice yourself
1:24
Days 57-60: Flask Login
1:04:10
Introduction: Flask Login
0:32
Let's start by setting some expectations
3:24
Your 4 day overview
3:15
Setup: Flask and Project directory
3:01
Setup: A Barebones Flask app
6:21
Define your database model
5:35
Specify the db object in __init.py__
2:45
Setup: Install SQLite DB Browser
0:53
Create the database!
3:16
Make the create-user Jinja Template
5:01
Add functionality to create users
5:46
Specify the app secret key
1:15
Let's add some users!
2:40
Incorporate Flask-Login
8:33
Test it! Login to the app
3:40
Create a quick logout page
3:43
What did we learn?
4:30
Days 61-64: Database migrations
25:45
Introduction to db migrations
2:28
Seeing the problem in action
2:32
Installing Alembic
3:45
Fix an error: Alembic distribution not found
1:47
Concept: Review configuring Alembic
2:03
Automatically detecting schema changes
5:09
Where is the DB version stored?
1:44
Concept: Alembic migrations
3:01
Your-turn: Days 2, 3, and 4
3:16
Days 65-68: Heroku and Python Platform-as-a-Service
43:30
Introduction: Heroku
0:59
Your 4 day overview
1:33
Setup your Heroku account and install the Heroku CLI
2:38
Setting up the local app and Heroku environment
4:37
Deploy and launch your first Heroku app!
7:39
What are Heroku addons?
3:53
Install Heroku scheduler
2:45
Automate sending emails with Heroku scheduler
6:25
Heroku SendGrid addon setup
3:45
Use SendGrid to send an email
6:23
What did we learn?
2:53
Days 69-72: Django REST Framework
42:39
Lesson intro
2:00
Virtual env, install dependencies and quotes app
5:02
Writing a custom django-admin command
7:54
Create a simple Django REST API
8:06
Implement the other CRUD methods
3:40
Django REST permissions: authentication and authorization
7:42
API documentation with Swagger
5:16
Day 3 + 4: Your turn - build your own API
2:59
Days 73-76: Web Scraping
42:27
Introduction: Web Scraping
0:45
Your next 4 days
3:56
Prepare to scrape!
2:27
Dive into BeautifulSoup4 and Talk Python
8:32
Write a Talk Python Training web scraping script
7:31
Installing and introducing newspaper3k
3:31
Extra! Extra! Student scrapes a news article!
8:07
What did we learn?
7:38
Days 77-80: Twitter and Slack bots
57:33
Lesson intro
1:20
4 day plan
1:21
Project: automate #100DaysOfCode tweeting
3:43
Dependencies and outline script
3:59
Manage config data with configparser
4:14
Turn on logging
3:47
Get a tweet with requests and BeautifulSoup
6:35
Post to Twitter with tweepy
7:08
Easy command line interface with argparse
5:47
Day 2 - Your turn / Twitter API practice
1:37
Project: random book slash command
1:40
Create a Slack app and slash command
3:13
Create a Flask app and call our books API
5:13
Response data and Slack message formatting
3:13
Testing out the slash command with ngrok
3:22
Day 4 - Your turn / Slack API practice
1:21
Days 81-84: Unit testing web apps
58:04
Why test web apps?
1:28
Testing challenges of web applications
2:34
3 types of tests
1:47
Setting up the app to be tested
1:50
Adding view models
5:25
View models applied to details page
2:43
View models and forms
3:19
Concept: View models
1:56
Our first unit test
5:43
Mocking out database access
3:41
More view model tests
5:25
Concept: View model unit tests
1:18
View unit tests: index page
4:13
Running all the tests at once
1:50
Concept: Testing view methods
1:44
Writing the functional tests
5:18
Concept: Functional tests
1:41
Concept: Web testing pareto principle
2:56
Your turn: Testing a web app
3:13
Days 85-88: Serverless Python with AWS Lambda
52:31
Lesson intro
2:29
A practical Lambda use case: CodeChalleng.es
2:20
4 day plan, PEP8 Checker app, setup
4:35
Build a simple Bottle web app
9:17
First Lambda: a simple calculator (using operator)
4:39
Creating Lambda test events
5:04
The glue: setting up AWS Gateway API
4:07
Second Lambda: PEP8 Checker (using pycodestyle)
11:38
Uploading a Lambda with external dependencies
5:36
Day 3 + 4: Your turn - create your own Lambda
2:46
Days 89-92: Deploying Python web apps to Linux
44:58
Deploy introduction
1:20
Deployment moving parts overview
2:58
Deployment: What app to install?
1:37
Where to host our server
2:18
Creating our virtual server
3:00
Connecting and updating the Linux server
1:48
Server software config
5:21
Getting the Python source files on the server
5:20
Setting up uWSGI
5:49
Serving through nginx
4:14
A final check-in on the server
1:47
Concept: uWSGI setup
2:57
Concept: nginx setup
1:36
Deploying Flask web apps
1:01
Deploying Django web apps
1:01
Your turn: Deployment
2:51
Days 93-96: Vue.js - JavaScript user interfaces
1:00:48
Vue.js Chapter Introduction
1:56
What does a simple Vue.js app look like?
2:20
The starter project: Movie Exploder
3:19
Creating the Vue app instance
4:27
Enabling the Vue.js Plugin in PyCharm and WebStorm
2:23
Repeating data and HTML blocks
2:20
Concept: Repeating data
1:03
First, with fake data
1:55
Detailed movie details
3:02
Conditional rendering
1:32
Concept: Conditional rendering
1:04
Searching movies event
3:18
Top ten button
1:34
Displaying and selecting genres
3:06
A nicer dropdown
2:58
Selecting the genre
1:14
Install the Vue.js devtools
2:05
Your turn: Day 2
2:04
Searching movies via the API and axios
5:22
Concept: Calling API with axios
1:06
Genres via the service
3:09
Top 10 movies from API
2:12
Movies by genre through the API
2:28
Setting attributes with Vue.js
2:32
Look; no semicolons
0:54
Your turn: Day 4
1:25
Days 97-100: Docker and Docker Compose
1:26:26
Introduction to Docker chapter
1:34
Container history: Boats
3:09
Container history: Operating systems
3:29
Installing Docker on macOS, Windows, and Linux
2:26
Docker nomenclature
4:02
Code setup
2:27
Choosing a Docker base image
1:55
Running a Docker container
3:17
Productivity with Docker plugins for Pycharm
1:00
Building a Docker image
6:13
Installing glances
3:52
Nginx config for our static site
5:47
Serving external traffic from Docker
3:58
Using the local services container
2:34
Docker image for our Python services
10:56
Running the system as a whole
3:40
Docker cleanup and reclaiming disk space
2:15
Keep your Docker DRY (refactoring)
3:15
Concept: Dockerfile for the static site
2:08
Concept: Core Docker commands
3:48
Your-turn, day 2
2:37
Concept: Introduction to docker-compose
2:20
Building the services with docker-compose
8:27
Your-turn, day 4
1:17
Conclusion
5:50
You've done it!
0:31
What you've learned
1:21
Make sure you have the source
0:29
Stay immersed in Python
1:08
Continue to challenge yourself with PyBites
1:10
Thanks and goodbye
1:11
Appendix: Python language concepts
46:01
Concept: The shape of a program
1:15
Concept: Variables
0:51
Concept: Truthiness
1:47
Concept: If else
1:24
Concept: Complex conditionals
1:31
Concept: for-in
1:41
Concept: Calling functions
0:59
Concept: Creating functions
1:33
Concept: File I/O
1:20
Concept: Imports and importing modules
1:59
Concept: Python package index
1:54
Concept: pip
2:26
Concept: Virtual environments
3:53
Concept: Slicing
2:53
Concept: Tuples
1:43
Concept: Named tuples
1:44
Concept: Classes
2:01
Concept: objects vs. classes
1:44
Concept: Inheritance
1:30
Concept: Polymorphism
0:53
Concept: Dictionaries
2:30
Concept: Error handling
2:38
Concept: lambdas
2:09
Concept: list comprehensions
2:57
Concept: Want more foundational Python?
0:46
Buy for $79 + tax Bundle and save 85% Team Gift

Questions? Send us an email: contact@talkpython.fm

Talk Python's Mastodon Michael Kennedy's Mastodon