How to Use Python: Your First Steps

Installing Python From Binaries

Regardless of your operating system, you can download an appropriate version of Python from the official site. Go there and grab the appropriate 32-bit or 64-bit version for your operating system and processor.

Selecting and downloading a Python binary from the language’s official site is often a good choice. However, there are some OS-specific alternatives:

• macOS: You have the option of installing Python from Homebrew.
• Linux: You can install several Python versions using your distribution’s package manager.
• Windows: You can install Python from the Microsoft Store.

You can also use the Anaconda distribution to install Python along with a rich set of packages and libraries, or you can use Miniconda if you want to install only the packages you need.

For further instructions on installing Python on different platforms, you can check out Python 3 Installation & Setup Guide.

Running Your Python Interpreter

You can do a quick test to ensure Python is installed correctly. Fire up your terminal or command line and run the python3 command. That should open a Python interactive session, and your command prompt should look similar to this:

Python 3.9.0 (default, Oct  5 2020, 17:52:02)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 

While you’re here, you might as well run your first line of code:

>>> print("Python is fun!")
Python is fun!

That’s it! You’ve just written your first Python program! When you’re done, you can use exit() or quit() to leave the interactive session, or you can use the following key combinations:

• macOS and Linux: Ctrl+D
• Windows: Ctrl+D and then press Enter

Keep your terminal or command line open. You still have more to do and learn! You’ll start by learning the basics of Python syntax.

Comments

Comments are pieces of text that live in your code but are ignored by the Python interpreter as it executes the code. You can use comments to describe the code so that you and other developers can quickly understand what the code does or why the code is written in a given way. To write a comment in Python, just add a hash mark (#) before your comment text:

# This is a comment on its own line

The Python interpreter ignores the text after the hash mark and up to the end of the line. You can also add inline comments to your code. In other words, you can combine a Python expression or statement with a comment in a single line, given that the comment occupies the final part of the line:

var = "Hello, World!"  # This is an inline comment

You should use inline comments sparingly to clear up pieces of code that aren’t obvious on their own. In general, your comments should be short and to the point. PEP 8 advises keeping comments at 72 characters or less. If your comment is approaching or exceeding that length, then you might want to spread it out over multiple lines:

# This is a long comment that requires
# two lines to be complete.

If you need more room for a given comment, then you can use multiple lines with a hash mark on each. This way, you can keep your comments under 72 characters in length.

Variables

In Python, variables are names attached to a particular object. They hold a reference, or pointer, to the memory address at which an object is stored. Once a variable is assigned an object, you can access the object using the variable name.

You need to define your variables in advance. Here’s the syntax:

variable_name = variable_value

You should use a naming scheme that makes your variables intuitive and readable. The variable name should provide some indication as to what the values assigned to it are.

Sometimes programmers use short variable names, such as x and y. These are perfectly suitable names in the context of math, algebra, and so on. In other contexts, you should avoid single-character names and use something more descriptive. That way, other developers can make an educated guess of what your variables hold. Think of others, as well as your future self, when writing your programs. Your future self will thank you.

Here are some examples of valid and invalid variable names in Python:

>>> numbers = [1, 2, 3, 4, 5]
>>> numbers
[1, 2, 3, 4, 5]

>>> first_num = 1
>>> first_num
1

>>> 1rst_num = 1
  File "<input>", line 1
    1rst_num = 1
    ^
SyntaxError: invalid syntax

>>> π = 3.141592653589793
>>> π
3.141592653589793

Your variable names can be any length and can consist of uppercase and lowercase letters (A-Z, a-z), digits (0-9), and also the underscore character (_). In sum, variable names should be alphanumeric, but note that even though variable names can contain digits, their first character can’t be a digit.

Finally, Python now offers full Unicode support, so you can also use Unicode characters in your variable names like you saw above with the variable π.

Keywords

Like any other programming language, Python has a set of special words that are part of its syntax. These words are known as keywords. To get the complete list of keywords available in your current Python installation, you can run the following code in an interactive session:

>>> help("keywords")

Here is a list of the Python keywords.  Enter any keyword to get more help.

False               class               from                or
None                continue            global              pass
True                def                 if                  raise
and                 del                 import              return
as                  elif                in                  try
assert              else                is                  while
async               except              lambda              with
await               finally             nonlocal            yield
break               for                 not

Each of these keywords plays a role in Python syntax. They are reserved words that have specific meanings and purposes in the language, so you shouldn’t use them for anything but those specific purposes. For example, you shouldn’t use them as variable names in your code.

There’s another way of getting access to the whole list of Python keywords:

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'cla
ss', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from
', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pas
s', 'raise', 'return', 'try', 'while', 'with', 'yield']

keyword provides a set of functions that allow you to determine if a given string is a keyword. For example, keyword.kwlist holds a list of all the current keywords in Python. These are handy when you need to manipulate keywords programmatically in your Python programs.

Built-In Data Types

Python has a handful of built-in data types, such as numbers (integers, floats, complex numbers), Booleans, strings, lists, tuples, dictionaries, and sets. You can manipulate them with several tools:

• Operators
• Built-in functions
• Data type methods

In the next few sections, you’ll learn the basics of incorporating Python’s built-in data types into your programs.

>>> # Addition
>>> 5 + 3
8

>>> # Subtraction
>>> 5 - 3
2

>>> # Multiplication
>>> 5 * 3
15

>>> # Division
>>> 5 / 3
1.6666666666666667

>>> # Floor division
>>> 5 // 3
1

>>> # Modulus (returns the remainder from division)
>>> 5 % 3
2

>>> # Power
>>> 5 ** 3
125

>>> # Integer numbers
>>> float(9)
9.0
>>> float(-99999)
-99999.0

>>> # Strings representing numbers
>>> float("2")
2.0
>>> float("-200")
-200.0
>>> float("2.25")
2.25

>>> # Complex numbers
>>> float(complex(1, 2))
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    float(complex(1, 2))
TypeError: can't convert complex to float

>>> # Floating-point numbers
>>> int(10.6)
10
>>> int(3.25)
3

>>> # Strings representing numbers
>>> int("2")
2
>>> int("2.3")
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    int("2.3")
ValueError: invalid literal for int() with base 10: '2.3'

>>> # Complex numbers
>>> int(complex(1, 2))
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    int(complex(1, 2))
TypeError: can't convert complex to int

>>> 10.0.is_integer()
True
>>> 10.2.is_integer()
False

>>> (10).bit_length()
4
>>> 10.bit_length()
  File "<input>", line 1
    10.bit_length()
      ^
SyntaxError: invalid syntax

>>> 2 < 5
True
>>> 4 > 10
False
>>> 4 <= 3
False
>>> 3 >= 3
True
>>> 5 == 6
False
>>> 6 != 9
True

>>> bool(0)
False
>>> bool(1)
True

>>> bool("")
False
>>> bool("a")
True

>>> bool([])
False
>>> bool([1, 2, 3])
True

>>> int(False)
0
>>> int(True)
1

>>> # Use single quotes
>>> greeting = 'Hello there!'
>>> greeting
'Hello there!'

>>> # Use double quotes
>>> welcome = "Welcome to Real Python!"
>>> welcome
'Welcome to Real Python!'

>>> # Use triple quotes
>>> message = """Thanks for joining us!"""
>>> message
'Thanks for joining us!'

>>> # Escape characters
>>> escaped = 'can\'t'
>>> escaped
"can't"
>>> not_escaped = "can't"
>>> not_escaped
"can't"

>>> "Happy" + " " + "pythoning!"
'Happy pythoning!'

>>> len("Happy pythoning!")
16

>>> " ".join(["Happy", "pythoning!"])
'Happy pythoning!'

>>> "Happy pythoning!".upper()
'HAPPY PYTHONING!'

>>> "HAPPY PYTHONING!".lower()
'happy pythoning!'

>>> name = "John Doe"
>>> age = 25
>>> "My name is {0} and I'm {1} years old".format(name, age)
"My name is John Doe and I'm 25 years old"

>>> name = "John Doe"
>>> age = 25
>>> f"My name is {name} and I'm {age} years old"
"My name is John Doe and I'm 25 years old"

>>> welcome = "Welcome to Real Python!"
>>> welcome[0]
'W'
>>> welcome[11]
'R'
>>> welcome[-1]
'!'

>>> welcome = "Welcome to Real Python!"
>>> welcome[0:7]
'Welcome'
>>> welcome[11:22]
'Real Python'

>>> # Define an empty list
>>> empty = []
>>> empty
[]

>>> # Define a list of numbers
>>> numbers = [1, 2, 3, 100]
>>> numbers
[1, 2, 3, 100]

>>> # Modify the list in place
>>> numbers[3] = 200
>>> numbers
[1, 2, 3, 200]

>>> # Define a list of strings
>>> superheroes = ["batman", "superman", "spiderman"]
>>> superheroes
['batman', 'superman', 'spiderman']

>>> # Define a list of objects with different data types
>>> mixed_types = ["Hello World", [4, 5, 6], False]
>>> mixed_types
['Hello World', [4, 5, 6], False]

>>> numbers = [1, 2, 3, 200]
>>> numbers[0]
1
>>> numbers[1]
2

>>> superheroes = ["batman", "superman", "spiderman"]
>>> superheroes[-1]
"spiderman"
>>> superheroes[-2]
"superman"

>>> numbers = [1, 2, 3, 200]
>>> new_list = numbers[0:3]
>>> new_list
[1, 2, 3]

>>> mixed_types = ["Hello World", [4, 5, 6], False]
>>> mixed_types[1][2]
6
>>> mixed_types[0][6]
'W'

>>> fruits = ["apples", "grapes", "oranges"]
>>> veggies = ["corn", "kale", "mushrooms"]
>>> grocery_list = fruits + veggies
>>> grocery_list
['apples', 'grapes', 'oranges', 'corn', 'kale', 'mushrooms']

>>> numbers = [1, 2, 3, 200]
>>> len(numbers)
4

>>> fruits = ["apples", "grapes", "oranges"]
>>> fruits.append("blueberries")
>>> fruits
['apples', 'grapes', 'oranges', 'blueberries']

>>> fruits.sort()
>>> fruits
['apples', 'blueberries', 'grapes', 'oranges']

>>> numbers_list = [1, 2, 3, 200]
>>> numbers_list.pop(2)
3
>>> numbers_list
[1, 2, 200]

>>> employee = ("Jane", "Doe", 31, "Software Developer")

>>> employee[0] = "John"
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    employee[0] = "John"
TypeError: 'tuple' object does not support item assignment

>>> employee = ("Jane", "Doe", 31, "Software Developer")
>>> employee[0]
'Jane'
>>> employee[1:3]
('Doe', 31)

>>> first_tuple = (1, 2)
>>> second_tuple = (3, 4)
>>> third_tuple = first_tuple + second_tuple
>>> third_tuple
(1, 2, 3, 4)

>>> numbers = (1, 2, 3)
>>> len(numbers)
3

>>> numbers = (1, 2, 3)
>>> list(numbers)
[1, 2, 3]

>>> letters = ("a", "b", "b", "c", "a")
>>> letters.count("a")
2
>>> letters.count("c")
1
>>> letters.count("d")
0

>>> letters = ("a", "b", "b", "c", "a")
>>> letters.index("a")
0

>>> letters.index("c")
3

>>> letters.index("d")
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    letters.index("d")
ValueError: tuple.index(x): x not in tuple

>>> person1 = {"name": "John Doe", "age": 25, "job": "Python Developer"}
>>> person1
{'name': 'John Doe', 'age': 25, 'job': 'Python Developer'}

>>> person2 = dict(name="Jane Doe", age=24, job="Web Developer")
>>> person2
{'name': 'Jane Doe', 'age': 24, 'job': 'Web Developer'}

>>> person1 = {"name": "John Doe", "age": 25, "job": "Python Developer"}
>>> person1["name"]
'John Doe'
>>> person1["age"]
25

>>> # Retrieve all the keys
>>> person1.keys()
dict_keys(['name', 'age', 'job'])

>>> # Retrieve all the values
>>> person1.values()
dict_values(['John Doe', 25, 'Python Developer'])

>>> # Retrieve all the key-value pairs
>>> person1.items()
dict_items([('name', 'John Doe'), ('age', 25), ('job', 'Python Developer')])

>>> employees1 = {"John", "Jane", "Linda"}
{'John', 'Linda', 'Jane'}

>>> employees2 = set(["David", "Mark", "Marie"])
{'Mark', 'David', 'Marie'}

>>> empty = set()
>>> empty
set()

>>> set([1, 2, 2, 3, 4, 5, 3])
{1, 2, 3, 4, 5}

>>> employees1 = {"John", "Jane", "Linda"}

>>> len(employees1)
3

>>> primes = {2, 3, 5, 7}
>>> evens = {2, 4, 6, 8}

>>> # Union
>>> primes | evens
{2, 3, 4, 5, 6, 7, 8}

>>> # Intersection
>>> primes & evens
{2}

>>> # Difference
>>> primes - evens
{3, 5, 7}

>>> primes = {2, 3, 5, 7}

>>> primes.add(11)
>>> primes
{2, 3, 5, 7, 11}

>>> primes = {2, 3, 5, 7, 11}

>>> primes.remove(11)
>>> primes
{2, 3, 5, 7}

Conditionals

Sometimes you need to run (or not run) a given code block depending on whether certain conditions are met. In this case, conditional statements are your ally. These statements control the execution of a group of statements based on the truth value of an expression. You can create a conditional statement in Python with the if keyword and the following general syntax:

if expr0:
    # Run if expr0 is true
    # Your code goes here...
elif expr1:
    # Run if expr1 is true
    # Your code goes here...
elif expr2:
    # Run if expr2 is true
    # Your code goes here...
...
else:
    # Run if all expressions are false
    # Your code goes here...

# Next statement

The if statement runs only one code block. In other words, if expr0 is true, then only its associated code block will run. After that, the execution jumps to the statement directly below the if statement.

The first elif clause evaluates expr1 only if expr0 is false. If expr0 is false and expr1 is true, then only the code block associated with expr1 will run, and so on. The else clause is optional and will run only if all the previously evaluated conditions are false. You can have as many elif clauses as you need, including none at all, but you can have only up to one else clause.

Here are some examples of how this works:

>>> age = 21
>>> if age >= 18:
...     print("You're a legal adult")
...
You're a legal adult

>>> age = 16
>>> if age >= 18:
...     print("You're a legal adult")
... else:
...     print("You're NOT an adult")
...
You're NOT an adult

>>> age = 18
>>> if age > 18:
...     print("You're over 18 years old")
... elif age == 18:
...     print("You're exactly 18 years old")
...
You're exactly 18 years old

In the first example, age is equal to 21, so the condition is true, and Python prints You're a legal adult to your screen. In the second example, the expression age >= 18 evaluates to False, so Python runs the code block of the else clause and prints You're NOT an adult on your screen.

In the final example, the first expression, age > 18, is false, so the execution jumps to the elif clause. The condition in this clause is true, so Python runs the associated code block and prints You're exactly 18 years old.

Loops

If you need to repeat a piece of code several times to get a final result, then you might need to use a loop. Loops are a common way of iterating multiple times and performing some actions in each iteration. Python provides two types of loops:

1. for loops for definite iteration, or performing a set number or repetitions
2. while loops for indefinite iteration, or repeating until a given condition is met

Here’s the general syntax to create a for loop:

for loop_var in iterable:
    # Repeat this code block until iterable is exhausted
    # Do something with loop_var...
    if break_condition:
        break  # Leave the loop
    if continue_condition:
        continue  # Resume the loop without running the remaining code
    # Remaining code...
else:
    # Run this code block if no break statement is run

# Next statement

This type of loop performs as many iterations as items in iterable. Normally, you use each iteration to perform a given operation on the value of loop_var. The else clause is optional and runs when the loop finishes. The break and continue statements are also optional.

Check out the following example:

>>> for i in (1, 2, 3, 4, 5):
...     print(i)
... else:
...     print("The loop wasn't interrupted")
...
1
2
3
4
5
The loop wasn't interrupted

When the loop processes the last number in the tuple, the flow of execution jumps into the else clause and prints The loop wasn't interrupted on your screen. That’s because your loop wasn’t interrupted by a break statement. You commonly use an else clause in loops that have a break statement in their code block. Otherwise, there’s no need for it.

If the loop hits a break_condition, then the break statement interrupts the loop execution and jumps to the next statement below the loop without consuming the rest of the items in iterable:

>>> number = 3
>>> for i in (1, 2, 3, 4, 5):
...     if i == number:
...         print("Number found:", i)
...         break
... else:
...     print("Number not found")
...
Number found: 3

When i == 3, the loop prints Number found: 3 on your screen and then hits the break statement. This interrupts the loop, and execution jumps to the line below the loop without running the else clause. If you set number to 6 or any other number that’s not in the tuple of numbers, then the loop doesn’t hit the break statement and prints Number not found.

If the loop hits a continue_condition, then the continue statement resumes the loop without running the rest of the statements in the loop’s code block:

>>> for i in (1, 2, 3, 4, 5):
...     if i == 3:
...         continue
...     print(i)
...
1
2
4
5

This time, the continue statement restarts the loop when i == 3. That’s why you don’t see the number 3 in the output.

Both statements, break and continue, should be wrapped in a conditional. Otherwise, the loop will always break when it hits break and continue when it hits continue.

You normally use a while loop when you don’t know beforehand how many iterations you need to complete a given operation. That’s why this loop is used to perform indefinite iterations.

Here’s the general syntax for a while loop in Python:

while expression:
    # Repeat this code block until expression is false
    # Do something...
    if break_condition:
        break  # Leave the loop
    if continue_condition:
        continue  # Resume the loop without running the remaining code
    # Remaining code...
else:
    # Run this code block if no break statement is run

# Next statement

This loop works similarly to a for loop, but it’ll keep iterating until expression is false. A common problem with this type of loop comes when you provide an expression that never evaluates to False. In this case, the loop will iterate forever.

Here’s an example of how the while loop works:

>>> count = 1
>>> while count < 5:
...     print(count)
...     count = count + 1
... else:
...     print("The loop wasn't interrupted")
...
1
2
3
4
The loop wasn't interrupted

Again, the else clause is optional, and you’ll commonly use it with a break statement in the loop’s code block. Here, break and continue work the same as in a for loop.

There are situations in which you need an infinite loop. For example, GUI applications run in an infinite loop that manages the user’s events. This loop needs a break statement to terminate the loop when, for example, the user exits the application. Otherwise, the application would continue running forever.

Functions

In Python, a function is a named code block that performs actions and optionally computes the result, which is then returned to the calling code. You can use the following syntax to define a function:

def function_name(arg1, arg2, ..., argN):
    # Do something with arg1, arg2, ..., argN
    return return_value

The def keyword starts the function header. Then you need the name of the function and a list of arguments in parentheses. Note that the list of arguments is optional, but the parentheses are syntactically required.

The final step is to define the function’s code block, which will begin one level of indentation to the right. In this case, the return statement is also optional and is the statement that you use if you need to send a return_value back to the caller code.

To use a function, you need to call it. A function call consists of the function’s name, followed by the function’s arguments in parentheses:

function_name(arg1, arg2, ..., argN)

You can have functions that don’t require arguments when called, but the parentheses are always needed. If you forget them, then you won’t be calling the function but referencing it as a function object.

Syntax Errors

Syntax errors occur when the syntax of your code isn’t valid in Python. They automatically stop the execution of your programs. For example, the if statement below is missing a colon at the end of the statement’s header, and Python quickly points out the error:

>>> if x < 9
   File "<stdin>", line 1
     if x < 9
            ^
SyntaxError: invalid syntax

The missing colon at the end of the if statement is invalid Python syntax. The Python parser catches the problem and raises a SyntaxError immediately. The arrow (^) indicates where the parser found the problem.

Exceptions

Exceptions are raised by syntactically correct code at runtime to signal a problem during program execution. For example, consider the following math expression:

>>> 12 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero

The expression 12 / 0 is syntactically correct in the eyes of the Python parser. However, it raises a ZeroDivisionError exception when the interpreter tries to actually evaluate the expression.

Python provides several convenient built-in exceptions that allow you to catch and handle errors in your code.

Semantic Errors

Semantic errors happen as a result of one or more problems in the logic of a program. These errors can be difficult to find, debug, and fix because no error message is generated. The code runs but generates unexpected output, incorrect output, or no output at all.

A classic example of a semantic error would be an infinite loop, which most programmers experience at least once in their coding lifetime.

REPLs (Read-Evaluate-Print Loops)

Although you can create functions in an interactive session, you’ll typically use the REPL for one-line expressions and statements or for short compound statements to get quick feedback on your code. Fire up your Python interpreter and type the following:

>>> 24 + 10
34

The interpreter simply evaluates 24 + 10, adding the two numbers, and outputs the sum, 34. Now try one more:

>>> import this

Take a minute to read the output. It states some important principles in Python, which will help you write better and more Pythonic code.

So far, you’ve used the standard Python REPL, which ships with your current Python distribution. However, this isn’t the only REPL out there. Third-party REPLs provide many useful features, such as syntax highlighting, code completion, and so on. Here are some popular options:

• IPython provides a rich toolkit to help you code in Python interactively.
• bpython is an interface to the Python interpreter for Linux, BSD, macOS, and Windows.
• Ptpython is a Python REPL that also works on Linux, BSD, macOS, and Windows.

Keep in mind that once you close the REPL session, your code is gone. In other words, the code typed into a REPL isn’t persistent, so you can’t reuse it. As a developer, you want code that you can reuse to save precious keystrokes. In this situation, code editors and IDEs come in handy.

Code Editors

The second approach to coding in Python is to use a code editor. Some people prefer an integrated development environment (IDE), but a code editor is often better for learning purposes. Why? Because when you’re learning something new, you want to peel off as many layers of complexity as possible. Adding a complex IDE into the mix can make the task of learning Python more difficult.

A Python program, in its bare-bones form, consists of lines of text (code) saved in a file with a .py or .pyw extension. You can write Python code in something as basic as Notepad on Windows, but there’s no reason to put yourself through such an ordeal since there are much better options available.

At its core, a code editor should provide several features to help programmers create programs. In most cases, you can customize the code editor to suit your needs and style. So, what should you look for in a code editor? The answer to this question might depend on your personal needs, but in general, you should look for at least the following features:

• Syntax highlighting
• Auto-indentation
• Auto-completion
• Tabbed interface
• Line numbering
• Customizable look and feel
• A curated set of plugins

Take a look at the following comparison example:

The code in the editor at the top (Sublime Text) is more readable due to the syntax highlighting and line numbering. The editor also identifies three errors, one of which is a showstopper. Can you figure out which one?

Meanwhile, the editor at the bottom (Notepad) doesn’t display the errors and is hard on the eyes since it’s in black and white.

Here’s a non-exhaustive list of some modern code editors that you can use:

• Visual Studio Code is a full-featured code editor available for Linux, macOS, and Windows platforms.
• Sublime Text 3 is a powerful and cross-platform code editor.
• Gedit is also cross-platform and comes installed in some Linux distributions that use GNOME.
• Notepad++ is also a great editor, but it’s for Windows only.
• Vim is available for Mac, Linux, and Windows.
• GNU Emacs is free and available on every platform.

There are many different options, both free and commercial, when it comes to code editors. Do your research and don’t be afraid to experiment! Keep in mind that your code editor should help you adhere to Python coding standards, best practices, and idioms.

IDEs (Integrated Development Environments)

An IDE is a program dedicated to software development. IDEs commonly integrate several features, such as code editing, debugging, version control, the ability to build and run your code, and so on. There are a lot of available IDEs that support Python or that are Python-specific. Here are three popular examples:

1. IDLE is Python’s Integrated Development and Learning Environment. You can use IDLE interactively exactly as you use the Python interpreter. You can also use it for code reuse since you can create and save your code with IDLE. If you’re interested in using IDLE, then check out Getting Started With Python IDLE.

2. PyCharm is a full-featured, Python-specific IDE developed by JetBrains. If you’re interested in using it, then check out PyCharm for Productive Python Development (Guide). It’s available on all major platforms and comes in free Edu and Community versions as well as a paid Professional version.

3. Thonny is a beginner-friendly IDE that will enable you to start working with Python right away. If you’re thinking of using Thonny, then check out Thonny: The Beginner-Friendly Python Editor.

This list of IDEs isn’t nearly complete. It’s intended to give you some guidance on how to get the right Python IDE for you. Explore and experiment before you make your choice.

The Standard Library

One of the great things about Python is the plethora of available modules, packages, and libraries both built into the Python core and made available by third-party developers. These modules, packages, and libraries can be quite helpful in your day-to-day work as a Python coder. Here are some of the most commonly used built-in modules:

• math for mathematical operations
• random for generating pseudo-random numbers
• re for working with regular expressions
• os for using operating system–dependent functionalities
• itertools for working with iterators
• collections for specialized container data types

For example, here you import math to use pi, find the square root of a number with sqrt(), and raise a number to a power with pow():

>>> import math

>>> math.pi
3.141592653589793

>>> math.sqrt(121)
11.0

>>> math.pow(7, 2)
49.0

Once you import math, you can use any function or object defined in that module. If you want a complete list of the functions and objects that live in math, then you can run something like dir(math) in an interactive session.

You can also import specific functions directly from math or any other module:

>>> from math import sqrt
>>> sqrt(121)
11.0

This kind of import statement brings the name sqrt() into your current namespace, so you can use it directly without the need to reference the containing module.

If you’re using modules, such as math or random, then make sure not to use those same names for your custom modules, functions, or objects. Otherwise, you might run into name conflicts, which can cause in unexpected behavior.

The Python Package Index and pip

The Python package index, also known as PyPI (pronounced “pie pea eye”), is a massive repository of Python packages that includes frameworks, tools, packages, and libraries. You can install any PyPI package using pip. This is one of the recommended tools for managing third-party modules, packages, and libraries in Python.

New coders frequently hit a wall when they’re following an example and they see ModuleNotFoundError: No module named module_x when they run the code. This means that the code depends on module_x, but that module isn’t installed in the current Python environment, creating a broken dependency. Modules like module_x can be manually installed using pip.

For example, say you’re trying to run an application that uses pandas, but you don’t have this library installed on your computer. In this case, you can open your terminal and use pip like this:

$ pip3 install pandas

This command downloads pandas and its dependencies from PyPI and installs them in your current Python environment. Once the installation is finished, you can run your application again and, if there’s no other broken dependency, the code should work.

Coding Is Like Riding a Bike

Coding is like riding a bike. You can watch people to learn how it’s done and sometimes you can get a push, but in the end, it’s a solo event. When you get stuck or need to brush up on a new concept, you can often work through the problem yourself by doing some research on Google. If you get an error message, then typing in the exact error message into Google will often bring up a result on the first page that might solve the problem.

Stack Overflow is another fundamental place to go when you’re looking for answers. The Q&A for coding has some great explanations of Python topics. Understanding slice notation and Manually raising (throwing) an exception in Python are just two truly excellent examples.

If you get stuck on a problem, then try these suggestions:

1. Stop coding!

2. Get a piece of paper and map out how to solve the problem using plain words. Use a flowchart if necessary.

3. Don’t use a try and except block until your code is working. The try can suppress valuable error messages that help identify problems in your code.

4. Use print() to quickly inspect your variables and make sure they have the expected value. This is an effective quick-and-dirty problem solver.

5. Use the rubber duck debugging technique. Explain your code, line by line, to the duck. You might find the solution to your problems in the process.

6. Use the Python Visualizer if you’re still stumped. This tool allows you to step through your code as it executes. The Python Visualizer has examples to help you if needed.

One final and important note: A frustrated brain is not going to help. When you start to get annoyed because something isn’t working, take a break to clear your mind. Go for a run or do something else. You will be amazed just how effective this can be. Often, you’ll come back with fresh eyes and see a simple typo, a misspelled keyword, or something similar.

Advising New Python Coders

Coders expect other coders, even beginners, to try and resolve the issue by themselves. At some point, though, you’ll need guidance. Once you’ve tried everything you can think of and have truly hit the wall, ask for help before you smash your keyboard or another inanimate object.

There are several places to get help, including code forums, Facebook groups, and the IRC channel #python, to name a few. Take a minute to read any rules or guidelines for any of the groups that you use. Make it easy for others to help you by explaining the problem and what you’ve tried. If there’s an error, then include that information as well.

Have fun coding!