Learn How to Program in Python

According to the the TIOBE Index at the time of this writing, Python is the most popular programming language in the world. And for good reason! You can do all sorts of things with Python. 

The language has found its way into a tremendous number of disciplines, such as Web/App Development (see Django, Flask, and fastapi), Data Analytics (see pandas, dash, and plotly), Data Science and Machine Learning (see scikit-learn, tensorflow, and streamlit), Data Engineering (see psycopg2, apache-airflow, and boto3), Hardware Development (see the Raspberry Pi project), and even Game Development (see pygame)! It's no wonder why it's the most popular programming language out there.

Python has come to be known as the "Swiss army knife" of programming due to its wide range of abilities. To learn how to program in Python, it's helpful to first have an awareness of its history. Below you can see my scrollable diagram of the summarized history that led to the development and release of the Python programming language.

Since the original release of Python in 1990, the language has gathered a vast and helpful community of enthusiasts and professionals. Some popular landing pages for the community include python.org and us.pycon.org.

Ongoing innovations from the community can be found in the "Python Package Index" (pypi.org). This is where you can download modules/packages from (more on that later!) and publish your own for others to use. Through the approval process of "Python Enhancement Proposals" (peps.python.org), the community grows the functionality of Python's core tooling. This same process has even developed a quirky, yet helpful, approach to Python programming, called the "Zen of Python." 

Some points from the Zen of Python are:

• Beautiful is better than ugly

• Explicit is better than implicit

• Simple is better than complex

• Complex is better than complicated

• Readability counts

Programming languages like Python continue to evolve each day, but the underlying mechanics that they abstract away remain ever-green. Knowing some basics of those underlying mechanics can help you more easily layer new tools and languages on top of your understanding. Those tools and languages often times will rotate to newer and better ones throughout the years, but the foundation remains constant.

First off, let's cover some basics that are easy to overlook when starting to learn how to program. Ultimately, programming boils down to a bunch of ones and zeros, true or false, if and else. That's it! But it's a lot easier said than done.

These ones and zeroes are referred to as "binary," which is essentially the language that computers speak and understand. To make it easier for us humans, we can speak to a computer through the use of higher-level programming languages, like Python, that translate our input into the binary that a computer can understand.

Having a rough idea of how Python translates to binary can be helpful context as you start learning the language. There's a lot that can be said about that, but just keep the following diagram in mind for now.

Python code is usually saved in .py files.  When you install Python, you'll have a program on your computer called  python. This program is called the "interpreter" and its job is to look at your Python code, compile it to bytecode and serialize that into machine readable code (e.g., binary) that your computer can understand and then execute. This moment is often referred to as "runtime," which is a word you'll sometimes hear throughout your learning.

There are several styles of programming out there. The most common are object-oriented programming, functional programming, and procedural programming. Each of these styles are available options when programming in Python, though the language is primarily known as an object-oriented programming language. Everything in Python is treated as "objects," which can contain data and/or code: data, in the form of fields, and code, in the form of procedures.

You can install Python onto your computer following these instructions. As a note, there are two major versions of Python that are in use today: Python 2 (legacy version) and Python 3. The older Python 2 is no longer actively maintained, but is still in operation due to the use of legacy applications from that time period. Python 3 is the recommended version of Python and is the version that is actively maintained today. 

As you start learning Python, there are important building blocks to be aware of, namely functions, classes, modules, packages, data types, and data structures. These topics are closely inter-connected with one another on their use-cases and how they operate. 

Functions:

A fundamental building block used across programming languages is the "function." Functions are just like what you might've learned about in some of your Math classes. A function is a pre-defined set of steps that takes an input and transforms it into a desired output. Python comes pre-equipped with built-in functions that are always available to you for solving common problems found in programming. You can also find more functions from modules and packages (more on this in the next section!) or you can create your own.

Classes:

A similar, yet different, building bock of the language is the "class." Classes serve as the essence of the object-oriented programming style in Python. Everything is treated as an "object" (i.e.,  A function, integer, list, etc.), every object has a "type," and every object type is created through the use of classes. A helpful distinction between functions and classes is that functions do specific things while classes are specific things. 

An object that belongs to a class is called an "instance" of that class. For example, the list data structure (see more on data structures below) is a class in Python. When we create a list, we have an instance of the list class.

Classes often have what are called "methods" built into them, which are functions that allow us to do things with instances of the class. For example, if I am working with an instance of the list class, I can use the method list.append() to add more items to that list! 

Data Types & Structures:

We use the above building blocks to work with and manipulate different data types and structures. Data types are common across programming languages and are simply forms of data like text (e.g., strings), numeric values (e.g., integers, floats, and complex numbers), and boolean values (e.g., true or false). Along with these data types, data structures are templates of how we can organize data in useful ways. 

Python comes with powerful data structures that cover ~80% of what you'll need for programming. The other 20% of use-cases can be met through data structures found in other Python modules/packages, such as the Pandas "dataframe." Included data structures are as follows:

• List - An ordered, mutable (e.g., can change) collection of data of any type that are contained within square brackets - [ ]. Lists are heterogeneous in Python, meaning they can contain different data types within the same list, such as numbers and strings. You can change a list at any time, including at runtime, by adding, removing, or changing the included objects. You can have a list of lists! 

• Dictionary - An unordered set of key-value pairs that are contained within curly braces - { } . This data structure is almost self-explanatory since each of us have had to use a dictionary when we needed to look up a definition of an English word!  The term "dictionary" might also be referred to by another name in other programming languages, such as associative array, map, symbol table, or hash. 

• Tuple - An ordered, immutable (e.g., cannot change) collection of objects that are contained within parentheses - ( ). The tuple is very similar to the list, except for the fact that once you have a tuple you can't change it. You might wonder, "What use is a list that cannot change?" Well, it turns out that there are plenty of use cases that you'll discover as you use Python more and more. 

• Set - An unordered group of unique objects. It is a handy data structure for remembering a collection of related objects while ensuring none of the objects are duplicated. Sets come with the added bonus in that it's easy to perform common data operations, like unions, intersections, and differences.

Modules & Packages:

The last important building blocks that I want to mention are "modules" and "packages," which will lead us into our next section!  A module is a collection of related functions stored in a .py file. You can source that file into your various Python projects so that you can re-use those functions, as needed. A package is very similar, but the difference is that a module is a singular .py file, while a package is a collection of modules. 

Python is a toy that comes with batteries included. Right from the start you'll have access to a set of helpful modules and packages that come from the standard library of Python.  In order to effectively learn the language, I recommend mastering this.

Python's Standard Library:

The standard library is quite large. Because of that, here are some module highlights that you can keep in mind:

• sys - Provides access to some variables used or maintained by the interpreter and to functions that interact strongly with the interpreter. It is always available.

• os - A portable way of using operating-system dependent functionality.

• subprocess - Allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes.

• traceback - A standard interface to extract, format and print stack traces of Python programs. It exactly mimics the behavior of the Python interpreter when it prints a stack trace. 

• datetime - Supplies classes for manipulating dates and times.

• time - Provides various time-related functions. 

• zoneinfo - Uses your system's time zone data (if available) or interfaces with the first-party tzdata package if no time zone data is available.

• json - Used to work with JSON files/objects, which is a lightweight format for storing and transporting data.

• urllib - A package that collects several modules for working with URLs

• random - Implements pseudo-random number generators for various distributions. 

• math - Provides access to the mathematical functions defined by the C standard. These functions cannot be used with complex numbers.

• statistics - Provides functions for calculating mathematical statistics of numeric and is aimed at the level of graphing and scientific calculators.

• itertools - Provides a standardized collection of tools for building custom iterations that are fast, memory efficient, and form an “iterator algebra” that makes it possible to construct specialized tools succinctly and efficiently in pure Python.

• functools - For higher-order functions that act on or return other functions. 

Other Modules/Packages:

Adding new modules and packages to your Python toolkit should be secondary to learning the standard library. However, you'll inevitably want to use other tools available from the Python community. I've found that it helps to first narrow the focus of your learning to a small, manageable set of functions, modules, and packages. 

For example, here is a list of modules/packages that I like! Each of these can be installed from pypi.org (see the next section).

• numpy - The fundamental package for scientific computing with Python.

• pandas - A powerful Python data analysis toolkit

• sqlalchemy - A SQL toolkit and Object Relational Mapper.

• requests - A simple, yet elegant, HTTP library.

• pyautogui - A cross-platform GUI automation tool for human beings that is used to programmatically control the mouse and keyboard.

• scipy - A useful package for mathematics, science, and engineering. The SciPy library depends on NumPy, which provides convenient and fast N-dimensional array manipulation.

• statsmodels - Provides a complement to SciPy for statistical computations, including descriptive statistics and estimation/inference for statistical models.

• jupyter - Installs the Jupyter system, including the notebook, qtconsole, and IPython kernel.

• pystan - An interface to Stan, a package for Bayesian inference.

• pymer4 - Makes it simple to perform multi-level modeling and fitting a variety of standard regression models with robust, bootstrapped, and permuted estimators. Inspired by R's lme4 package.

• prophet - Used for forecasting time series data where non-linear trends can be fit with yearly, weekly, and daily seasonality, plus holiday effects.

• Django - A high-level web framework that encourages rapid development and clean, pragmatic design.

• dash - A framework for building reactive web-apps that ties modern UI elements like drop-downs, sliders, and graphs directly to your analytical Python code.

• plotly - An interactive data visualization library.

• matplotlib - A comprehensive library for creating static, animated, and interactive visualizations in Python.

• seaborn - A data visualization library that provides a high-level interface for drawing attractive statistical graphics.

• plotnine - An implementation of a grammar of graphics in Python, based on R's ggplot2 library, which allows users to compose plots by explicitly mapping data to the visual objects that make up the plot.

• scikit-learn - The most popular package for machine learning and data science/mining. 

• streamlit -  A framework to quickly create beautiful and performant data applications.

• tensorflow - A library that allows easy deployment of high-performance, numerical computations across a variety of hardware (i.e., CPUs, GPUs, and TPUs) and platforms (i.e., desktops, server clusters, and edge devices).

• apache-airflow - A platform makes it easy to programmatically author, schedule, and monitor workflows. 

• boto3 - Used to create, configure, access, and manage AWS services.

• psycopg2 - The most popular PostgreSQL database adapter for the Python programming language.

• beautifulsoup4 - A library that makes it easy to scrape information from web pages.

• dotenv - Reads key-value pairs from a .env file and can set them as environment variables.

• pydantic - Data validation and settings management using type hints.

• typing - Defines a standard notation for annotations that can be used for documenting code in a concise, standard format.

You Need an IDE:

An Integrated Development Environment (IDE) is an important tool that you will need when learning Python. Out of the box, the language comes with IDLE, which is a small, yet usable, IDE. However, the IDE I recommend is either VS Code or Jupyter. If I am doing typical engineering work, I prefer VS Code. If I am doing data science work, I prefer using Jupyter. A powerful combination is the use of VS Code + Docker Dev Container + Jupyter Notebook together, but that explanation requires a separate article (coming soon!).

If you choose to use VS Code as your preferred IDE, these are some of the Python extensions I would recommend:

• Python -  Rich support for the Python language, including features such as IntelliSense (Pylance), linting, debugging, code navigation, code formatting, refactoring, variable explorer, test explorer, and more!

• Pylance - A performant, feature-rich language server for Python in VS Code

• Jupyter - Jupyter notebook support, interactive programming and computing that supports Intellisense, debugging and more.

• Jupyter Keymap - This extension provides keymaps for notebooks in Visual Studio Code to match the keybindings in Jupyter Notebook. This extension comes with the Jupyter extension for Visual Studio Code and can be disabled or uninstalled.

• Jupyter Notebook Renderers - Renderers for Jupyter Notebooks (with plotly, vega, gif, png, svg, jpeg and other such outputs)

• Jupyter Notebook VS Code - Runs jupyter notebooks in VS Code

You Need Package Management:

To learn more about package management, I highly recommend watching the Pluralsight course Managing Python Packages and Virtual Environments by Reindert-Jan Ekker. You can sign up for a free Pluralsight trial here.

One of the most troublesome issues in Python development is "package management." It's been a headache for the community that has spurred the creation of a variety of helpful tools. To avoid this pesky issue, I recommend familiarizing yourself with both pip and poetry. Understanding how to use these tools will also help you further master the above modules/packages. A popular alternative worth noting is conda, which is a package manager focused on the data science community.

Working in Virtual Environments:

A "virtual environment" is an isolated container for using different Python versions and installing modules/packages. Using a virtual environment together with your package management tools is a powerful and important combination. Doing so helps ensure that your projects are reproducible and can stand independent from one another, avoiding dependency conflicts across your projects. My advice to you is to always work inside a virtual environment by using popular tools, like venv,or virtualenv. As a side note, I also highly recommend working in Docker Dev Containers with VS Code (future article coming soon), which is another approach to virtual environments.

There comes a point where you will need to put down the textbooks/courses and start building something with Python. Having a project to apply your learning towards is the best way to learning a new programming language. Find a way to use Python for your benefit in the form of a project, whether that might be a homework assignment, school project, your job, or a personal project that you're interested in.

Don't be afraid to approach your learning in a variety of ways. Other tools I would recommend are:

• Use Pluralsight to strategically direct your learning. The platform offers a host of video courses, interactive content, and assessments that can help you move from beginner to expert, quickly. Their "Skill IQ" assessments will help you identify your skill gaps in Python and recommend relevant content to help you fill those skill gaps.

• Read Python Head First, 2nd Edition, an in-depth and intuitive book on Python.

• Use websites/apps that offer interactive puzzles and questions to help you get hands-on experience:

  • CodinGame - Quick competitions and fun puzzles that gamify the learning process.

  • Kaggle - Long running Data Science competitions that offer interesting problems and a helpful community and online forums.

  • Leetcode - Serious interview prep for technical roles.

• Get a Raspberry Pi and program it to do something helpful using Python.

• Get involved with the open-source community!

  • Stackoverflow.com - If you get stuck, don't hesitate to look on Stackoverflow for a solution or even ask your own question there.

  • GitHub.com - Store your code and find other interesting projects from people across the world!

If you found any of my content helpful, please consider donating
by using one of the following options  —  Anything is appreciated!