Taking Python to Production- A Professional Onboarding Guide

Taking Python to Production: A Professional Onboarding Guide, available at $69.99, has an average rating of 4.81, with 175 lectures, 1 quizzes, based on 228 reviews, and has 2732 subscribers.

You will learn about Set up a professional Python development environment – Visual Studio Code, pyenv, git, autocompletion Learn the professional git workflow with GitHub and CI/CD with GitHub Actions Make the terminal more intuitive with ZSH and plugins Version and package Python software and publish it for the community Setup automated code quality checks (testing, linting, documentation, type checking, etc.) This course is ideal for individuals who are Lower-intermediate to advanced Python developers who meet the requirements and are interested in the learning outcomes. or Data scientists, analysts, junior developers, and self-taught developers who want want to set up a development environment for writing production-ready software It is particularly useful for Lower-intermediate to advanced Python developers who meet the requirements and are interested in the learning outcomes. or Data scientists, analysts, junior developers, and self-taught developers who want want to set up a development environment for writing production-ready software.

Enroll now: Taking Python to Production: A Professional Onboarding Guide

Summary

Title: Taking Python to Production: A Professional Onboarding Guide

Price: $69.99

Average Rating: 4.81

Number of Lectures: 175

Number of Quizzes: 1

Number of Published Lectures: 175

Number of Published Quizzes: 1

Number of Curriculum Items: 176

Number of Published Curriculum Objects: 176

Original Price: $34.99

Quality Status: approved

Status: Live

What You Will Learn

Set up a professional Python development environment – Visual Studio Code, pyenv, git, autocompletion

Learn the professional git workflow with GitHub and CI/CD with GitHub Actions

Make the terminal more intuitive with ZSH and plugins

Version and package Python software and publish it for the community

Setup automated code quality checks (testing, linting, documentation, type checking, etc.)

Who Should Attend

Lower-intermediate to advanced Python developers who meet the requirements and are interested in the learning outcomes.

Data scientists, analysts, junior developers, and self-taught developers who want want to set up a development environment for writing production-ready software

Target Audiences

Lower-intermediate to advanced Python developers who meet the requirements and are interested in the learning outcomes.

Data scientists, analysts, junior developers, and self-taught developers who want want to set up a development environment for writing production-ready software

This is a course about transitioning from a “coder” to a “software engineer”. It specifically covers the tools needed to develop and “ship” production-ready software with Python.

As an MLOps engineer, my role is to help enable data scientists, analysts, and junior engineers become more self-sufficient at bringing products to production.

This course covers a mix of foundational tools, engineering practices, and career advice that new engineers should be given during the onboarding process when they join a team (but they often don’t get guidance!).

By the end of this course, you should feel confident contributing to complex software projects in a team setting, whether open-source or at a company (or please request a refund within 30 days!).

You will understand how closed- and open-source projects are run and how to run your own.

In the course, we write very little code and instead focus on the non-coding aspects of software engineering that make you an effective member of the software engineering community.

That said, you should have a solid grasp of Python fundamentals (loops, functions, classes, etc.) before taking this course.

Expect to learn

how to set up a professional Python development environment

how to set up a professional workflow for Python development with Visual Studio Code; extra emphasis on autocompletion

how to use git, GitHub, “branching strategies”, and their integrations with VS Code and the terminal

how to write clean, maintainable code and ensure that all code contributed to your projects is good quality (testing, linting, formatting, type checking, documentation, etc.)

how to publish production-quality software for a wide audience with packaging, versioning, continuous integration, and continuous delivery (pre-commit, GitHub Actions, PyPI)

how to templatize all of the above points, so you can create new, high-quality projects in seconds

Before paying for this course, please sample the preview lectures so you can get a sense of whether it’s right for you.

See you in the course!

– Eric

Course Curriculum

Chapter 1: Introduction

Lecture 1: Course introduction

Lecture 2: IMPORTANT! Course Notes and Course Website

Lecture 3: Linux and terminal crash course

Chapter 2: Environment Setup

Lecture 1: Install VS Code

Lecture 2: Make sure you have the `code` command

Lecture 3: Mac users only: Install Homebrew, Xcode, and iTerm2

Lecture 4: Windows users only: Install the Windows Subsystem for Linux (WSL2)

Lecture 5: Windows users only: Integrate VS Code with the WSL2

Lecture 6: Resources: Installing git

Lecture 7: Installing the git CLI tool

Chapter 3: Improving the terminal with ZSH

Lecture 1: Introduction

Lecture 2: Installing OhMyZSH

Lecture 3: Navigating using ZSH and installing ZSH plugins

Lecture 4: The ~/.zshrc file and ZSH themes

Lecture 5: Disabling/enabling ZSH plugins; All-in-one Markdown extension; web-search plugin

Lecture 6: Typeahead auto-completion with zsh-autosuggestions

Lecture 7: Syntax highlighting with zsh-syntax-highlighting

Lecture 8: Cheat sheet: quick ZSH setup

Chapter 4: Managing multiple Python versions

Lecture 1: Introduction to Semantic Versioning (semver)

Lecture 2: Semantic Versioning (continued)

Lecture 3: Why developers need to be able to switch between multiple Python versions

Lecture 4: Resources for installing pyenv

Lecture 5: Installation and overview of pyenv for managing multiple Python versions

Lecture 6: History of Python changes; Overview of how Python evolves

Chapter 5: VS Code: shortcuts, auto-completion, and virtual environments

Lecture 1: VS Code keyboard shortcut reference

Lecture 2: VS Code: layout and key shortcuts

Lecture 3: Python/Pylance: improve refactoring and syntax highlighting support

Lecture 4: Step debugging in VS Code

Lecture 5: Preview of virtual environments

Lecture 6: Python virtual environments and the PATH variable

Chapter 6: Git and VS Code

Lecture 1: Introducing git by comparing it to Google Docs

Lecture 2: Git lens extension

Lecture 3: Git command reference

Lecture 4: git CLI and commits

Lecture 5: Making a commit

Lecture 6: Time traveling and best practices for making commits

Lecture 7: git stash

Lecture 8: (Part 1) git branching – visual intuition

Lecture 9: (Part 2) git branching – hands-on in VS Code

Lecture 10: Merging git branches

Lecture 11: Resolving merge conflicts

Lecture 12: [Extra] git branching game

Lecture 13: git tags

Lecture 14: Recap: the local git workflow

Chapter 7: GitHub and Code Review

Lecture 1: Preview of the rest of the course

Lecture 2: What is GitHub?

Lecture 3: Creating a repository in GitHub

Lecture 4: Cloning and git remotes

Lecture 5: Pull Requests and Code Review

Lecture 6: Conducting Code Review with a Pull Request

Lecture 7: Recap: the remote git workflow

Chapter 8: Continuous Integration: clean code, formatters, linters and VS Code integrations

Lecture 1: Section guide: resources, links, assignments, summary notes, etc.

Lecture 2: Clean code and why its important

Lecture 3: Python style guides: Google and PEP 8

Lecture 4: Refactoring for better readability

Lecture 5: Introduction to Continuous Integration and best practices for PRs

Lecture 6: PR hell and more discussion of Continuous Integration

Lecture 7: Autoformatting with Black, VS Codes settings system, and Holy Wars

Lecture 8: Pylint Part 1 – Introducing Linters

Lecture 9: Pylint Part 2 – Integrating with VS Code

Lecture 10: Pylint Part 3 – Configuring Pylint w/ a config file and CLI arguments

Lecture 11: Flake8 Part 1 – Usage and background

Lecture 12: Flake8 Part 2 – Flake8 plugins w/ Darglint as an example

Lecture 13: isort: sorting import statements

Lecture 14: Code metrics like cyclomatic complexity with Radon, Xenon, and McCabe

Lecture 15: Typing Part 1 – type hints, autocompletion, static vs dynamic type checking

Lecture 16: Typing Part 2 – Mypy and basic typing

Lecture 17: Typing Part 3 – Simple and Complex Types

Lecture 18: Typing Part 4 – Union and Optional

Lecture 19: Typing Part 5 – TypedDict, dataclasses, NamedTuple, self-referential types

Lecture 20: Typing Part 6 – Generic Types

Lecture 21: Typing Part 7 – Type Stubs and incrementally adding types to existing codebases

Lecture 22: Darker: incrementally lint legacy projects

Lecture 23: Ruff: the last Python linter ever?

Chapter 9: Continuous Integration – The pre-commit framework

Lecture 1: A Continuous Integration workflow with code quality tools

Lecture 2: CI Approach 1 – Writing a script that calls each tool

Lecture 3: Git pre-commit hooks

Lecture 4: CI Approach 2 – The pre-commit framework

Lecture 5: Pre-commit hook roundup

Lecture 6: Tour of an advanced pre-commit config file

Chapter 10: GitHub Actions

Lecture 1: Our first GitHub Actions workflow

Lecture 2: GitHub Actions: running a workflow

Lecture 3: Fixing the build and using pre-commit

Lecture 4: Branch permissions, merge checks, and pull requests

Lecture 5: Understanding GitHub Actions Pricing

Lecture 6: Optimizing for cost by using GitHub Actions Triggers

Chapter 11: Python Packaging

Lecture 1: Section Intro – Python Packaging

Lecture 2: PYTHONPATH and imports in Python

Instructors

Eric Riddoch
Instructor | ML Platform Lead Engineer

Rating Distribution

1 stars: 1 votes

2 stars: 0 votes

3 stars: 8 votes

4 stars: 38 votes

5 stars: 181 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!