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

100 days of code is not just about the commitment. The true power and effectiveness is in having a guide and pursuing the "right-sized" projects. That's why we have 33 deeply practical projects. Each paired with 20-40 minute lessons at the beginning of the project.

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

Understating basic Python data structures
Searching large text corpuses with regular expressions
Consume HTTP services including the Twitter and GitHub APIs among others
Visual data with graphs using Descriptionly
Convert your Python CLI (command line interface) app to a GUI application
Program against Excel in Python to automate your spreadsheet data
Build a text-based game and learn object-oriented programming
Automate multi-step web processes using selenium
Test your code with pytest and unit testing
Create a basic web app with Flask
Create a JSON-based online game service using Flask too
And 22 more projects!

Welcome to the course:
Welcome to the course
The rules of #100DaysOfCode
Topics covered
Why Python for #100DaysOfCode
Course flow
Meet your instructors
Need a Python primer?
Get the source code
Three devs are better than one
Julian's setup
Bob's setup
Michael's tool's and setup
PyBites code challenge platform
Video player: A quick feature tour

Days 1-3: Playing with Datetimes:
Lesson introduction
Your 3 day overview
Learning datetime and date
Datetime timedelta usage
Concepts: what did we learn

Days 4-6: Collections module:
Lesson introduction
Namedtuples: more readable code
Defaultdicts: factory for data structures
Counter: don't reinvent the wheel
Deque: when lists become slow
Concepts: what did we learn
Second day: use collections on movie data
Third day: get more practice

Days 7-9: Python Data Structures:
Introduction to Data Structures
Your 3 day overview
Manipulating Lists
Immutability and Tuples
Creating and Parsing Dictionaries
Concepts: what did we learn

Days 10-12: Testing your code with pytest:
Lesson introduction
The importance of testing
Setup and a guessing game to test
Hello test world - unittest vs pytest
Mocking randomness / pytest-cov
Mocking user input and exceptions
Testing a program's stdout with capfd
Testing (simulating) the game end-to-end
A TDD primer writing Fizz buzz
Concepts: what did we learn
Second day: use pytest on your code
Third day: writing pytest fixtures

Days 13-15: Text-based games (and classes):
Introduction to the chapter
Modeling concepts: Inheritance, classes, and objects
Demo: Initial project structure
Demo: Building our classes
Demo: Implementing the game play
Concept: Classes
Your turn: Day 1
Your turn: Day 2
Your turn: Day 3

Days 16-18: List comprehensions and generators:
Lesson introduction
Writing a simple list comprehension
Cleaning data with list comprehensions
Generators - the basics
Use generators to build a sequence
List vs generator performance
Concepts: what did we learn
Second day: a practical exercise
Third day: solution and islice
Third day: more code challenges

Days 19-21: Iteration with itertools:
Introduction to the lesson
Your 3 day overview
Iteration Refresher
Itertools - Cycle
Itertools - Product
Combinations and Permutations
Traffic Lights Project
Concepts: what did we learn?

Days 22-24: Decorators:
Lesson introduction
Quick primer on decorators
Function argument types: args and kwargs
Write a timeit decorator (wraps)
More abstraction: stacking decorators
Examples of real life decorators
Concepts: what did we learn
Second day: a practical exercise
Third day: write your own decorator

Days 25-27: Error handling:
Introducing Python's error handling
Demo: The starter app skeleton
Demo: try-except blocks
Demo: Error types
Concepts: Error handling and exceptions
Your turn: Day 1
Your turn: Day 2
Your turn: Day 3

Days 28-30: Regular Expressions:
Lesson introduction
When not to use regexes
Comparing re.search and re.match
String capturing parenthesis
findall is your friend
Compiling regexes with re.VERBOSE
Using re.sub for string replacing
Concepts: what did we learn
Second day: write your own regexes
Third day: more regex exercises

Days 31-33: Logging:
Introduction to logging
Logging with Logbook
Demo: Introducing our app
Demo: Configuring logging
Demo: Writing the log messages
Demo: Logging a the API level
Demo: File logging
Concepts: Logging
Your turn: Day 1
Your turn: Day 2
Your turn: Day 3

Days 34-36: Refactoring / Pythonic code:
Lesson introduction
Refactoring 1: if-elif-else horror
Refactoring 2: loop counting == enumerate
Refactoring 3: with statement (context managers)
Refactoring 4: use built-ins / standard library
Refactoring 5: tuple unpacking and namedtuples
Refactoring 6: list comprehensions and generators
Refactoring 7: string formatting and concatenation
Refactoring 8: PEP8 and Zen of Python
Refactoring 9: be explicit in your exceptions
Refactoring 10: quality code best practices
Refactoring / code quality resources
Concepts: what did we learn
Your turn: Day 2 and 3

Days 37-39: Using CSV data:
Introduction to CSV programming
Some amazing data sets
Our data
Demo: Getting started with CSV processing
Demo: Reading the CSV file contents
Demo: Parsing the CSV file
Demo: Converting our CSV data to a usable form
Demo: Answer the questions
Concepts: CSV programming
Your turn: Day 1
Your turn: Day 2
Your turn: Day 3

Days 40-42: JSON in Python:
Introduction to JSON
Your 3 day overview
Inspecting JSON schema
Request JSON data from an API
Parsing nested dicts in JSON
Concepts: what did we learn

Days 43-45: Consuming HTTP services:
Introduction to HTTP APIs
Exploring the service
Introducing the Postman app
The requests package
Demo: Building the program structure
Demo: Downloading search results
Demo: Data version one: dicts
Demo: Data version two: Better results
Concepts
Your turn: Day 1
Your turn: Day 2
Your turn: Day 3

Days 46-48: Web Scraping with BeautifulSoup4:
Introduction to BeautifulSoup4
Your 3 day overview
Setting up the environment
A quick BS4 overview
Building your first BS4 scraper
Requests best practice
Detailed BS4 scraping and searching
Concepts: what did we learn

Days 49-51: Measuring performance:
Introduction to profiling
Intuition fail
Demo: Getting started
Demo: Focus on our code
Demo: Fine-tuning collection with the API
Demo: Even more focused collection
Demo: Faster with less data processed
PyCharm's profiling
Concepts: Profiling
A quantum warning
Your turn: Day 1
Your turn: Day 2
Your turn: Day 3

Days 52-54: Parsing RSS feeds with Feedparser:
Lesson introduction
Your 3 day overview
Setting up our Feedparser environment
Pulling the feed with Requests
Parsing XML with Feedparser
Feedparser Sanity Check
Concepts: what did we learn

Days 55-57: Structured API clients with uplink:
Introducing uplink
A glimpse at an API
Use the official API if available
Demo: Getting started
Demo: Exploring the service
Demo: Creating the client
Demo: Getting a individual post
Demo: Only success responses
Demo: Writing a new post
Demo: Better wrappers and helpers
Concepts: uplink
Your turn: Day 1
Your turn: Day 2
Your turn: Day 3

Days 58-60: Twitter data analysis with Python:
Lesson introduction
Create a Twitter app
Virtual environment and env variables
Get all tweets with tweepy.Cursor
Identify the most popular tweets
Most common hashtags and mentions
Build a Twitter wordcloud
Concepts: what did we learn
Second + third day: practice projects

Days 61-63: Using the Github API with Python:
Lesson introduction
Setup and creating a Github user object
Quick detour: getting help in Python
Ranking user's repos by popularity
Creating a gist with the Github API
Inspecting Github objects with pdb
Concepts: what did we learn
Second day: examples / get practice
Third day: more practice / requests-cache

Days 64-66: Sending emails with smtplib:
Introduction to sending Emails
Your 3 day overview
Obtaining your Gmail App ID
Email Project Setup
Sending an Email with smtplib
Getting into MIME
Emailing with BCC
Concepts: what did we learn

Days 67-69: Copy and Paste with Pyperclip:
Lesson introduction
Your 3 day overview
Setup: Install Pyperclip and your env
Pyperclip Usage
Demo: Affiliate script
Demo: Pyperclip text replacer
Concepts: what did we learn

Days 70-72: Excel automation with openpyxl:
Lesson introduction
Your 3 day overview
Setup: install openpyxl and your env
Understanding workbooks and worksheets in openpyxl
Working with cell values
Using maxrow
Inserting data into a worksheet
Concepts: what did we learn

Days 73-75: Automate tasks with Selenium:
Lesson introduction
Setup: install Selenium and ChromeDriver
Hello world Selenium: search python.org
Demo 1: access my Packt ebook collection
Demo 2: automating PyBites banner creation
Concepts: what did we learn
Your turn: Day 2
Your turn: Day 3

Days 76-78: Getting Started with Python Flask:
Flask introduction
Your 3 day overview
Setting up the environment
Creating your first Flask app!
Dict data in Flask
Concepts: what did we learn

Days 79-81: Basic Database Access with SQLite3:
A brief intro to SQLite3 Databases
Your 3 day overview
Installing SQLite DB Browser
Creating a simple SQLite3 address book
Analysing the DB with SQLite DB Browser
Demo: Script to Generate a DB
Inserting data into the address book
Demo: Script to populate the address book
Pulling data with SELECT
Concepts: what did we learn

Days 82-84: Data visualization with Descriptionly:
Lesson introduction
Installing feedparser and Descriptionly
Prep 1: parse PyBites RSS feed data
Prep 2: useful data structures for Descriptionting
Prep 3: transpose data and init Descriptionly
Creating bar and pie charts with Descriptionly
Other data visualization libraries
Concepts: what did we learn
Second day: build your own graphs
Third day: extra inspiration / keep coding

Days 85-87: Fullstack web apps made easy:
Fullstack web introduction
What is fullstack development?
What app will we build?
Introducing Anvil
Anvil building blocks
Creating a new project in Anvil
Adding navigation
Subforms
Linking the forms
Building the Add new document form
Processing add new document
Data tables
Anvil server code
Creating the document
Add document finale
All docs
A refactoring
Adding filtering
Document details form
Publishing our web app
Anvil concepts
Your turn: Day 1
Your turn: Day 2
Your turn: Day 3

Days 88-90: Home Inventory App:
Lesson Introduction
Your 3 day overview
Writing and working the main menu
SQLite3 database usage
Scrub function - SQLite3 workaround
Home Inventory app run through
Bug and functionality fixes
Your Turn! - Fix the app

Days 91-93: Database access with SQLAlchemy:
Introducing SQLAlchemy
Demo: Introducing our app
Demo: The app skeleton
Demo: Defining database classes
Demo: Defining columns (via classes)
Demo: Connecting to the database
Demo: Using the data access layer (DAL)
Demo: The final game
Demo: Seeing the database
Concepts: SQLAlchemy
Your turn: Day 1
Your turn: Day 2
Your turn: Day 3

Days 94-96: Rich GUI apps in Python:
Introduction to Python UIs
Demo: Where we are starting
Demo: Refactoring to isolate user input
Demo: Adding Gooey to our app
Demo: Packaging our app for redistribution
Concepts: Gooey
Your turn: Day 1
Your turn: Day 2
Your turn: Day 3

Days 97-99: Building JSON APIs:
Introducing our online game server
What API operations are required?
Getting started: Program structures
Adding the Flask basics
Defining JSON methods in Flask
Migrating our SQLAlchemy models
Ensuring starter data
Defining the API methods in Flask
Exercising the API
Implementing the all-rolls method
Implementing the create-game method
Implementing the find-user method
Implementing the create-user method
Implementing the game-status method
Implementing the top-scores method
Implementing the play-round method
Refactoring our web code for single responsibility
Implementing the client
Making the client self-validating
Writing the full client
Implementing the game (client-side)
Your turn: Day 1
Your turn: Day 2
Your turn: Day 3

Day 100:
The final day

Course conclusion:
You've done it!
What you've learned
Make sure you have the source
Stay immersed in Python
Continue to challenge yourself with PyBites
Thanks and goodbye

Appendix: Python language concepts:
Concept: The shape of a program
Concept: Variables
Concept: Truthiness
Concept: If else
Concept: Complex conditionals
Concept: for-in
Concept: Calling functions
Concept: Creating functions
Concept: File I/O
Concept: Imports and importing modules
Concept: Python package index
Concept: pip
Concept: Virtual environments
Concept: Slicing
Concept: Tuples
Concept: Named tuples
Concept: Classes
Concept: objects vs. classes
Concept: Inheritance
Concept: Polymorphism
Concept: Dictionaries
Concept: Error handling
Concept: lambdas
Concept: list comprehensions
Concept: Want more foundational Python?


Who is this course for?

This course is for anyone who wants to immerse themselves in Python for 100 days worth of learning and 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.