 Courses from Will Button

Python is a widely used dynamically typed programming language. It allows for many different programming paradigms including object-oriented, imperative, functional programming, and procedural styles.

python

In this lesson, you will learn how to statically type variables in Python 3.6 Static typing can help you avoid errors when consumers of your variables and functions call them with the incorrect data type. You will learn how to statically type strings, integers, booleans, Lists and Dicts. You will also learn how to automatically check for typing errors when coding and as part of your build workflow.

Use Static Typing in Python 3.6

In this lesson, you'll get a quick introduction on how to use Jinja2 templates to render HTML using a Flask server in Python.
Topics covered:
- Where to store your HTML templates
- How to pass variables to the Jinja2 template
- How to render the resulting HTML in Flask

Use Jinja2 templates to render HTML in Flask

In this lesson, you will learn:

How to install Flask
Use Flask to create a minimal website
Build routes in Flask to respond to website endpoints
Use Variable Rules to pass parts of the URL to your functions as keyword parameters

Create a minimal website in Python using the Flask Microframework

In this lesson, you will learn how to create a one to many relationship between two database tables using SQLAlchemy.
Tasks covered include:
- creating a child table
- defining a foreign key in the child table
- creating the relationship between the parent and child table
- demonstrate usage in Python
- view the data created in a local sqlite database

Create a one to many relationship in Python using SQLAlchemy


In this lesson, you will be introduced to SQL Alchemy. You will learn how to create a base entity to provide common defaults for all database tables, create a table to track available inventory, and create python methods to list and update data in the database.

Use SQL Alchemy to Interact with a Database

In this lesson, you will learn the difference between appending an item to a list and extending a list in Python using the `.append()` and `.extend()` methods

List append vs. List extend in Python

In this lesson, you will learn how to implement pytest fixtures. Many unit tests have the same resource requirements. For example, an instantiated object from a class. You will learn how to create the instance of the class one time as a fixture and reuse that object across all your tests.
This results in faster tests, eliminates duplicate code, and uses less resources when running your tests.

Use pytest fixtures to reduce duplicated code across unit tests

In this lesson you will create a new project with a virtual environment and write your first unit test with pytest. In doing so, you will learn:
- install pytest
- organize your project to support automated test discovery
- setup Visual Code to use pytest as your test engine
- best practice naming conventions for tests in Python

Write Your First Python Unit Test with pytest

In this lesson, you will be introduced to Python generators. You will see how a generator can replace a common function and learn the benefits of doing so. You will learn what role the `yield` keyword provides in functions and how it differs from a `return`. Building on that knowledge, you will learn how to build a generator to recursively crawl an API (swapi.co) and return Star Wars characters from "The Force Awakens".

Use a Python Generator to Crawl the Star Wars API

Why should you have to write all the code? Why can’t you leverage code written by others? I’ve got great news: you can. You’ll learn how to search pip, Python’s package installer, to find and install packages to add new features and functionality to your application.

Manage packages with pip in Python

Object oriented classes work much like classes in other languages. Learn how to create them and use them, learn the difference between class variables and instance variables, creating class methods, and learn how to create classes that inherit from other classes.

Use Python Classes

Functions allow you to encapsulate your code into a reusable component. Learn how to create functions, add arguments to your functions, assign default values to arguments, and use keyword arguments.

Create Reusable Components with Functions in Python

Misunderstanding scope can cause problems in your application. Watch this lesson to learn how Python scope works and the hidden implications it presents. Local scope, nonlocal scope, and global scope variables are demonstrated and explained.

Understand Scope in Python

A module is a function extracted to a file. This allows you to import the function and use it in any other code you may write. You’ll learn how to create modules, import them, and make them stand-alone as you learn what `if __name__ == “__main__”` means in Python.

Reuse Code in Multiple Projects with Python Modules

Exceptions cause your application to crash. Handling them allows you to recover gracefully and keep your application running. Learn how to handle exceptions, find what exceptions you should be handling, and exit gracefully in this lesson. You will also learn how you should *not* handle exceptions and when it is better to let your application crash rather than swallowing an exception. 

Handle Exceptions to prevent crashes in Python

`Dir` and `help` are two must-know functions in Python. `Dir` will provide us with a list of methods available on the object of interest while `help` will inspect a specific method we would like to use.

Learning about them in this lesson will help you understand what functions and methods are available for use as well has how to use them.

Invoke the built-in help system with python's dir and help methods

Single quotes and double quotes can both be used to declare strings in Python. You can even use triple-double quotes! Learn when to use each in this lesson as well as variable substitution in strings.

Format Strings in Python

This lesson will teach you how to read the contents of an external file from Python. You will also learn how to use the python csv module to read and parse csv data, as well as the json module to read and parse json data.

Read and Parse Files in Python

This lesson will teach you how to write to an external file in Python, either by replacing the file completely or appending to an existing file.

Write to a File in Python

List comprehensions provide a concise way to create new lists, where each item is the result of an operation applied to each member of an existing list, dictionary or other iterable. Learn how to create your own list comprehensions in this lesson.

Understand List Comprehensions in Python

You may already be familiar with arrays. In Python, they are known as lists. Learn how to create, append, remove, sort, and reverse lists in this lesson.

Use Lists in Python

Mock Service Worker is an API mocking library that allows you to write client-agnostic mocks and reuse them across any frameworks, tools, and environments.



Mocking WebSocket APIs with Mock Service Worker


While using anonymous functions might seem convenient, they can create difficulties when trying to identify performance bottlenecks during profiling. This lesson will demonstrate how named functions make it easier to pinpoint and address performance issues, ultimately leading to more efficient and debuggable code. Learning this practice will greatly improve your ability to locate and fix performance issues in complex projects.

Always Name Functions in JavaScript


When attempting to load the same module twice in JavaScript you'll hit a cache and code won't re-run. In scenarios where you actually do want to have state in your modules, you'll have to use a cache-busting technique by passing a query parameter to a dynamic import. This lesson walks through how to add a query parameter, how to add the appropriate types for loading dynamic modules in TypeScript, and when these techniques are valuable.

Import the Same JavaScript Module Multiple Times with Cache Busting



The include keyword in GitHub Actions empowers you to add custom variables to your matrix strategy, providing flexibility beyond standard configurations. In this video, we'll explore how include allows you to define specific combinations of variables, enhancing control over your workflow runs. You'll see how this feature enables you to tailor jobs for unique environments or scenarios not covered by the default matrix options. By leveraging include, you can efficiently manage complex build processes with greater precision. This technique helps you streamline your CI/CD pipeline, making it more adaptable to your project's evolving needs.

Use GitHub Actions Matrix Include for Complex Job Configurations

While running `zod` schema validation agains domain-rich objects, the error message saying that _a string is not a number_ might not be really useful.

Especially, when you need to provide a meaningful feeback to the user, e.g. after they have submitted a form with lots of data.

`zod` allows to customize messages on a very granular level. We can also extract repeatable customization to `zod` error maps.

Finally, in order to process an error message further (e.g. display it to the user), we need to handle the `zod` validation errors effectively. Especially, when a big object validation has failed and we could receive a handful of errors.

That's what we learn in this lesson. 🔥

Customize zod Error Messages and Handle zod Errors Effectively

customize zod validation messages, customize zod schema property messages, reuse error maps across different schemas, navigate through zod error objects

You might want to run `zod` schema checks in different styles.

Sometimes you prefer to conditionally throw the error - that's what `parse` does. But another time you'd prefer to receive a `boolean` property that determines whether the validation was successful or not - and perform further actions accordingly.

Additionally, the error-throwing API of `parse` works extremely well with [TypeScript assertion functions](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions). Their combination is just... perfect! 👌

That's what we learn in this lesson.

Use parse and safeParse Runtime Type-checks with zod

use zod parse function to conditionally throw ZodError, use zod safeParse to get a boolean value and run typescript type guard over success property

In this lesson we learn that TypeScript cannot guarantee correct shapes of responses. That's due to TS performing checks in compile-time, while the response will be availbale in runtime - when TS doesn't exist anymore.

In some situations, such as HTTP requests, runtime type checks such as `zod` are essential for providing quick feedback around data-related errors.

Understand where are the possible mistakes to make while using TypeScript with HTTP calls. Use `fetch` and `axios` along with `zod` schema checks.

Also, note that similar mistakes or mistakes could happen while using web storage (e.g. `localStorage`)

Validate HTTP API Response with zod, fetch and axios

use zod as an HTTP response validation tool along with fetch and axios in order to make sure that the response has expected data structure

In this lesson we learn that the `zod` schemas become the single source of truth.

We shall not update TypeScript types manually, since they are generated automatically from the schema.

Same with validation functions.

Whenever the schema changes, all the rest will update accordingly. It's an important mind shift.

Treat zod Schemas as Single Source of Truth

Zod Schemas are the single source of truth for both typescript types, and interfaces - and runtime validation functions. Schemas should be updated first.

`zod` is powerful, but writing the schemas manually for existing JSON objects, especially big ones, can be time-consuming.

But that's what `quicktype` is for! You can get 80% work done instantly! 🥳

Depending on your need - whether you want to automate the process, or do it just one time, you can:
- use an online app
- use an IDE extension
- run a CLI script
- generate a script to be executed within CI/CD environment/tooling

And this is what we learn in this lesson! 🔥🔥🔥

Get started with zod quickly!

Generate zod Schemas Automatically using Quicktype App, Extensions and Scripts

Use quicktype app, extension or scripts to automatically generate zod schemas from existing json files. Save time and get started with zod quickly!

`zod` is a powerful library allowing to run runtime type-checks.

It's complementary to TypeScript, which does type checks in compile time.

In this lesson we create few schemas that represent primitive type values, along with `zod` utilities which make these more precise. We also create object schemas and nest one inside another.

All schemas are being validated against example values. We analyze how to interpret error messages in case of failures.

Perform Runtime Type-checks on Primitives and Objects with zod

Create zod schemas to validate primitive type and object type values in runtime. Analyze the errors to see how a value doesn't correspond to schema expectations

Will Button

Search Results