CF

Rock Solid Python with Python Typing Course

4h 27m 54s
English
Paid

Rock Solid Python with Python Typing Course is a 73-lesson 4 hours 27 minutes self-paced course by Talk Python Training. Since its inception in 1989, Python has evolved from a dynamic and typeless language to one that embraces type hints, starting with the introduction in Python 3.

Course facts

Lessons
73
Duration
4 hours 27 minutes
Level
All levels
Language
English
Updated
Instructor
Talk Python Training
Price
Premium

Since its inception in 1989, Python has evolved from a dynamic and typeless language to one that embraces type hints, starting with the introduction in Python 3.5. This change sparked the development of powerful, type-safe frameworks such as Pydantic, FastAPI, Beanie, SQLModel, and more. In this course, you will master Python typing, explore various frameworks utilizing types, and gain valuable advice on implementing types in your projects.

Course Highlights

Throughout this course, you will:

  1. Compare Python with popular static languages like Swift, C#, and TypeScript.
  2. Analyze a dynamic Python codebase versus its typed counterpart to understand differences and benefits.
  3. Learn to create typed variables effectively and understand when to apply them.
  4. Explore Python's strict nullability within its type system.
  5. Specify constant variables and values to ensure immutability.
  6. Reduce SQL injection risks using LiteralString.
  7. Utilize typing with Python functions and methods for clearer code.
  8. Implement typing in classes and with class variables for better design.
  9. Navigate Python's numerical type hierarchy to manage multiple numerical types.
  10. Use Pydantic for modeling and parsing complex data with strict type enforcement.
  11. Create APIs using FastAPI to maintain type integrity during data exchange.
  12. Query databases efficiently by leveraging Pydantic and Beanie ODM.
  13. Develop CLI applications using type information for defining interfaces.
  14. Enhance codebase integrity with mypy during CI/CD pipelines.
  15. Add runtime type safety to boost application reliability.
  16. Integrate duck typing with static typing using Python's novel Protocol construct.
  17. Acquire design patterns and guidance for proficient use of types in Python development.

Additional

https://github.com/talkpython/rock-solid-python-with-type-hints-course

Who teaches Rock Solid Python with Python Typing Course? Talk Python Training

Talk Python Training thumbnail

Talk Python Training is the paid course platform of Michael Kennedy, the host of the long-running Talk Python To Me podcast — one of the most-listened-to podcasts in the Python ecosystem. The course platform extends Michael's interview-based knowledge of the field into structured video courses taught by Michael and a curated set of guest instructors.

The course catalog covers the full Python landscape: web development with Django, Flask, FastAPI, and the broader async-Python stack; data science and pandas; LLM / RAG application development; testing and CI/CD; deployment patterns; the data-engineering side of Python; and a long list of practical Python patterns aimed at working developers. Few platforms cover the language with this much breadth from inside the Python community itself.

The CourseFlix listing under this source carries over 18 Talk Python Training courses spanning that range. Material is paid; Talk Python Training runs on per-course pricing on the original platform. Courses are aimed at developers using Python as a serious primary language rather than as a scripting tool.

What lessons are included in Rock Solid Python with Python Typing Course?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 73 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Welcome
All Course Lessons (73)
#Lesson TitleDurationAccess
1
Welcome Demo
01:57
2
Python Language Typing Definition
02:41
3
What We'll Cover
02:42
4
Goal: Not 100%
01:11
5
You'll Need Python 3.10 or Newer
01:07
6
git the Repo
01:22
7
Meet Your Instructor
01:38
8
Spectrum of Type Strictness
06:37
9
Running the Source Code
03:26
10
Motorcycle Class, Untyped
05:36
11
Using the Untyped Motorcycle
02:21
12
Duck Typing
03:03
13
TypeScript Motorcycles
04:40
14
C# Motorcycle and Why Types Can Detract from Readability
05:02
15
A Very Swift Motorcycle
04:04
16
Typed Python Motorcycles
07:38
17
Python Typing Introduction
00:33
18
Where Do Python Type Hints Come From?
01:14
19
Typing and Variables
03:23
20
Survey of Core Types
03:05
21
Nullable Types
05:22
22
Unions
03:11
23
If You Don't Know the Type
02:03
24
Constants
03:37
25
Avoiding Injection Attacks with LiteralString
06:02
26
Functions: Basic Typing
05:13
27
Functions: void Functions
02:44
28
Functions: Functions as Objects
05:34
29
Typing for Container Data Types
07:22
30
More Complex Containers
08:28
31
Classes and Typing
06:27
32
Externally Defining Types
04:27
33
Adding Our Own Types
03:56
34
Representing Multiple Numerical Types
04:13
35
Generics Available in Python 3.12
01:45
36
Gradual Typing
03:11
37
Frameworks Introduciton
00:46
38
Pydantic Foundations
02:24
39
Pydantic Code Example
01:00
40
pip-tools for Adding Requirements
03:16
41
Parsing Basic Data with Pydantic
08:57
42
Data-Rich Pydantic Example
06:03
43
Web frameworks using Type Hints
04:58
44
Database Frameworks Built on Pydantic
03:40
45
CLIs with Python Types
02:09
46
Setting up Our FastAPI Example
03:43
47
FastAPI, Beanie, and Pydantic MongoDB Example
04:27
48
Setting up the DB to Run the Code Yourself
02:08
49
Tools Introduction
00:42
50
Editors (Round 2)
02:26
51
Full Project Inspection
06:12
52
Static Type Checkers
01:32
53
mypy in Action
05:14
54
Runtime Type Checking with Beartype
01:56
55
Getting Started with Beartype
06:43
56
Beartype Speed Test
07:01
57
Orthogonal/Structural Typing Introduction
01:06
58
Inheritance Gone Wrong, an Example
06:11
59
Static duck typing with Protocols
08:24
60
Structural Typing Visualized
01:19
61
Patterns Introduction
01:11
62
Types on the Boundary
02:05
63
Public Packages
01:30
64
Autocomplete
01:10
65
To Optional or Not
03:11
66
Versions of Python
04:19
67
Minimalism Overview
04:12
68
Minimalism Code
01:45
69
Refactoring Motivation
01:31
70
Refactoring with Types
02:37
71
Point of No Return
07:39
72
Collection Advice
02:27
73
Conclusion
05:05
Unlock unlimited learning

Get instant access to all 72 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to Rock Solid Python with Python Typing Course?

Frequently asked questions

What are the prerequisites for this course?
To enroll in this course, you need Python 3.10 or newer. Familiarity with basic Python programming concepts is recommended, as the course dives into advanced topics like typing and frameworks such as Pydantic and FastAPI. Understanding of version control with Git is also helpful since you'll need to 'git the Repo' to access course materials.
What projects or skills will I build during the course?
During the course, you'll work on developing APIs using FastAPI, which maintains type integrity during data exchange. You'll also learn to model and parse complex data using Pydantic with strict type enforcement, and query databases efficiently leveraging Beanie ODM. Additionally, you'll develop CLI applications using type information to define interfaces, enhancing your skills in type-safe application development.
Who is the target audience for this course?
The course is aimed at Python developers who are looking to deepen their understanding of Python typing. It is particularly beneficial for those interested in building robust, type-safe applications using modern frameworks like FastAPI and Pydantic. Developers transitioning from static languages like Swift, C#, and TypeScript may also find the comparisons between these languages and Python useful.
How does this course compare in depth to other Python courses?
This course offers an in-depth exploration of Python's typing system, comparing it to static languages such as Swift, C#, and TypeScript. It covers advanced topics like nullable types, unions, and the use of LiteralString to reduce SQL injection risks. The course also delves into specific frameworks like Pydantic and FastAPI, providing a focused look at type-safe development, which may not be covered in general Python courses.
What specific tools or platforms are taught in the course?
The course covers several tools and platforms, including Pydantic for data modeling and parsing, FastAPI for creating APIs, and Beanie ODM for database interaction. It also introduces pip-tools for managing dependencies and mypy for static type checking. Additionally, the course discusses runtime type checking with Beartype and uses Git for version control of course materials.
What topics are not covered in this course?
The course does not cover basic Python programming concepts or introductory topics. It assumes a working knowledge of Python and focuses instead on advanced typing, type-safe frameworks, and related tools. Concepts like basic syntax, control structures, and standard library usage are not part of the curriculum.
What is the expected time commitment for this course?
The course consists of 73 lessons, though the total runtime is not specified. Given the depth of the material, prospective students should be prepared to invest a significant amount of time to fully engage with the content, complete exercises, and apply the concepts in practical projects. A commitment of several weeks, depending on the student's pace, might be necessary to complete the course thoroughly.