How to Use Python: Your First Steps

Install Python From Binaries

Regardless of your operating system, you can download an appropriate version of Python from the official site. Go there and select 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 on Windows 10 and later versions. Before doing so, make sure the publisher is the Python Software Foundation (PSF). After installation, Python, pip, and IDLE will be available.

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

Once you’ve installed Python on your system using your preferred method, you can start using the Python interpreter in interactive mode.

Run the Python Interpreter

You can do a quick test to ensure Python is installed correctly. Open your terminal or command line and run the python3 command. This will start a Python interactive session, also known as the REPL. Your command prompt should look similar to this:

$ python3
Python 3.13.7 (main, Aug 22 2025, 19:20:01) [GCC 14.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

While you’re in this interactive session, you can run your first line of code:

>>> print("Hello, World!")
Hello, World!

When you press Enter, Python prints Hello, World! to the screen. That’s it! You’ve just written your first Python program in an interactive session!

You can use exit() or quit() to leave a Python interactive session and return to the system shell. If you’re using Python 3.13 or later, then you can also use the exit and quit commands (no parentheses) to leave the REPL.

Alternatively, you can use the following key combinations to finish a session:

• Ctrl+D on macOS and Linux
• Ctrl+Z and Enter on Windows

Keep your terminal or command line open. You still have more to do and learn! You’ll start with 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 quickly document certain parts of your code so that other developers can understand what the code does or why it’s written a certain 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 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 is at the end of the line:

greeting = "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 practice, 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 comment, then you can use multiple lines with a hash mark on each. This way, you can keep your comments under 72 characters.

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 you assign an object to a variable, you can access the object using that variable name.

To use a Python variable in your code, you need to define it 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 and 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

>>> π = 3.141592653589793
>>> π
3.141592653589793

>>> 1rst_num = 1
  File "<python-input-6>", line 1
    1rst_num = 1
    ^
SyntaxError: invalid decimal literal

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

Python offers full Unicode support, so you can also use Unicode characters in your variable names, such as the π variable shown above. However, while Python permits Unicode characters in identifiers, most style guides (including PEP 8) recommend sticking to ASCII letters, digits, and underscores for variable names. This helps avoid confusion, tooling issues, and potential security pitfalls.

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 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. In fact, Python will prevent this by raising a syntax error if you try.

Python also has what’s known as soft keywords. These are keywords that retain their meaning only in specific contexts. Unlike normal keywords, you can use soft keywords as identifiers if needed.

Here’s how you can access the whole list of Python keywords and soft keywords:

>>> import keyword

>>> keyword.kwlist
[
    'False',
    'None',
    'True',
    'and',
    ...
    'yield'
]

>>> keyword.softkwlist
['_', 'case', 'match', 'type']

The keyword module provides objects and functions that allow you to work with Python keywords. For example, keyword.kwlist and keyword.softkwlist hold lists of all the current keywords and soft keywords in Python.

Built-in Data Types

Python has a handful of built-in data types, such as numbers (integers, floats, and complex numbers), Booleans, strings, bytes, lists, tuples, dictionaries, and sets.

You can manipulate the built-in data types using different tools. Here are some of them:

• Operators
• Built-in functions
• Methods

In the following sections, you’ll learn how to use Python’s built-in data types, including numbers, Booleans, strings, bytes, lists, tuples, dictionaries, and sets, with quick practical examples.

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

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

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

>>> # True 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):
    ...
TypeError: float() argument must be a string or a real number, not 'complex'

>>> # 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):
    ...
ValueError: invalid literal for int() with base 10: '2.3'

>>> # Complex numbers
>>> int(complex(1, 2))
Traceback (most recent call last):
    ...
TypeError: int() argument must be a string, a bytes-like object
⮑ or a real number, not 'complex'

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

>>> (10).bit_length()
4
>>> 10.bit_length()
  File "<python-input-3>", line 1
    10.bit_length()
      ^
SyntaxError: invalid decimal literal

>>> 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

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

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

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

>>> # Escape characters
>>> 'can\'t'
"can't"
>>> "can't"
"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[0:7]
'Welcome'

>>> welcome[11:22]
'Real Python'

>>> # Literal syntax (ASCII only)
>>> b"Hello"
b'Hello'

>>> # From an iterable of integers (0 to 255)
>>> bytes([72, 101, 108, 108, 111])
b'Hello'

>>> # By encoding a string
>>> "café".encode("utf-8")
b'caf\xc3\xa9'

>>> data = b"caf\xc3\xa9"
>>> data.decode("utf-8")
'café'

>>> packet = b"ABCDEF"
>>> len(packet)
6
>>> packet[0]
65
>>> packet[1:4]
b'BCD'

>>> buffer = bytearray(b"ABC")
>>> buffer[0] = 97
>>> buffer
bytearray(b"aBC")
>>> bytes(buffer)
b'aBC'

>>> b"Hello".hex()
'48656c6c6f'

>>> bytes.fromhex("48656c6c6f")
b'Hello'

>>> # 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
>>> ["batman", "superman", "spiderman"]
['batman', 'superman', 'spiderman']

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

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

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

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

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

>>> mixed_types[1][2]
6

>>> fruits = ["apples", "grapes", "oranges"]
>>> veggies = ["corn", "kale", "spinach"]

>>> fruits + veggies
['apples', 'grapes', 'oranges', 'corn', 'kale', 'spinach']

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

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

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

>>> numbers = [1, 2, 3, 4]
>>> numbers.pop(2)
3
>>> numbers
[1, 2, 4]

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

>>> employee[0] = "John"
Traceback (most recent call last):
    ...
TypeError: 'tuple' object does not support item assignment

>>> type((1))
<class 'int'>

>>> type((1,))
<class 'tuple'>

>>> 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):
    ...
ValueError: tuple.index(x): x not in tuple

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

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

>>> john["name"]
'John Doe'

>>> john["age"]
25

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

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

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

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

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

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

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

>>> employees = {"John", "Jane", "Linda"}
>>> len(employees)
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 a given code block depending on whether certain conditions are met. In this situation, conditional statements are your allies. They’re control flow statements that manage the execution of a code block based on the truth value of a condition.

You can create a conditional statement in Python with the if, elif, and else keywords. Here’s the general syntax:

if condition_0:
    # Run if condition_0 is true
    <block>
elif condition_1:
    # Run if condition_1 is true
    <block>
elif condition_2:
    # Run if condition_2 is true
    <block>
...
else:
    # Run if all expressions are false
    <block>

The code block under if only runs if the condition is true. The elif and else clauses are optional. The first elif clause evaluates condition_1 only if condition_0 is false. If condition_0 is false and condition_1 is true, then only the code block associated with condition_1 will run, and so on.

The else clause will run only if all the previous conditions are false, providing a default code block. You can have as many elif clauses as you need, including none at all, but you can only have 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. In the second example, the expression age >= 18 is false, and Python runs the code block of the else clause, printing You're NOT an adult on your screen.

In the final example, age > 18 is false, so 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

Sometimes, you need to traverse an iterable of data or repeat a piece of code several times. In this scenario, you can use a loop. Python provides two types of loops:

1. for loops
2. while loops

Python’s for loops are designed to iterate over the items in a collection, such as lists, tuples, strings, and dictionaries. In contrast, while loops are useful when you need to execute a block of code repeatedly as long as a given condition remains true.

Here’s the general syntax for creating 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

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

Here’s a quick example of a for loop that allows you to iterate over a tuple of numbers:

>>> 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 to 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 include at least one break statement in their code block. Otherwise, there’s no need for it.

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

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

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

If the continue_condition is true, then the continue statement resumes the loop without running the remaining 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 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 typically use a while loop when you don’t know beforehand how many iterations you need to complete a given operation. Here’s the general syntax for a while loop in Python:

while condition:
    # Repeat this code block as long as the condition is true
    # 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

This loop works similarly to a for loop, but it’ll keep iterating until condition becomes false. A common problem with this type of loop comes when you provide a condition that never evaluates to False. In such cases, you’ll have a potentially infinite loop.

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

>>> count = 1
>>> while count < 5:
...     print(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. The break and continue statements work the same way in a for loop.

There are situations where 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 independently. You often create this type of intentionally infinite loop using the while True: pattern.

Functions

In Python, a function is a named code block that performs actions and optionally computes the result, which can be 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 here...
    return return_value

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

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

To use a function, you need to call it with the appropriate arguments if needed. 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 parentheses are always needed. If you forget them, then you won’t be calling the function but referencing it as a function object.

Classes

Classes let you bundle data (attributes) and behavior (methods) into reusable blueprints for objects. They’re a core part of object-oriented programming in Python and help you model concepts from your problem domain.

Here’s a quick example of how to create a class and instantiate it:

>>> class Dog:
...     def __init__(self, name, age):
...         self.name = name
...         self.age = age
...
...     def bark(self):
...         return "Woof! Woof!"
...

>>> fido = Dog("Fido", 3)
>>> fido.name, fido.age
('Fido', 3)
>>> fido.bark()
"Woof! Woof!"

The class keyword allows you to define the class. Then, you have the .__init__(), which runs when you create a new object and initializes its attributes.

Once you’ve defined a class, you can create instances using the class constructor with appropriate arguments. Finally, you can access the attributes and methods on the instance.

Imports

Imports allow you to reuse code by bringing modules and packages into your main program. They’re a critical tool for programs where you split the code into multiple .py files.

Here are some quick examples of common syntax constructs that you’ll use to import modules and objects in your Python code:

>>> import math
>>> math.sqrt(16)
4.0

>>> from math import sqrt
>>> sqrt(25)
5.0

>>> from math import pi as PI
>>> PI
3.141592653589793

In these examples, you import math and use dot notation to call sqrt(). Then, you import the sqrt() function directly into your current session and call it again. Finally, you import pi as PI, which is an alias.

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 its header, and Python quickly points out the error:

>>> if x < 9
  File "<python-input-0>", line 1
    if x < 9
            ^
SyntaxError: expected ':'

The missing colon at the end of the if statement is invalid Python syntax. Python’s parser catches the problem and immediately raises a SyntaxError exception. The ^ character 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 "<python-input-0>", line 1, in <module>
    12 / 0
    ~~~^~~
ZeroDivisionError: division by zero

The expression 12 / 0 is syntactically correct from the Python parser’s perspective. However, it raises a ZeroDivisionError exception when the interpreter tries to 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, incorrect output or no output at all.

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

REPLs

Although you can write complex code in an interactive session, you typically use the REPL for one-line expressions and statements or for short compound statements to get quick feedback from your code. Open your Python interpreter and type the following:

>>> 24 + 10
34

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

>>> import this

Take a moment to read the output of this import. 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 the official CPython distribution. However, this isn’t the only REPL out there. Third-party REPLs provide many useful features, such as syntax highlighting, code completion, and history. 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, and macOS.
• 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 saved, 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

Code editors are often good 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 simplest 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 are much better options available that make coding and learning easier.

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
• Autocompletion
• Tabbed interface
• Line numbering
• Plugins
• AI-assisted workflows

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

• Visual Studio Code is a full‑featured code editor for Linux, macOS, and Windows.
• Sublime Text is a fast, cross‑platform editor with a rich plugin ecosystem.
• Neovim is a modern Vim with an extensible Lua‑based plugin system.
• Zed is a high‑performance, collaborative editor available on macOS and Linux.
• Cursor is an AI‑assisted editor built on the VS Code ecosystem, available on macOS, Windows, and Linux.
• Notepad++ is a popular, lightweight editor for Windows.
• GNU Emacs is an extensible, cross‑platform editor.

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

An integrated development environment (IDE) is a program dedicated to software development. IDEs commonly integrate features such as code editing, debugging, version control, test running, and environment management. Here are solid, up‑to‑date options that work great with Python:

• IDLE ships with Python and provides an interactive shell, a code editor, and a basic debugger. It’s ideal for first steps. For a friendly walkthrough, see Getting Started With Python IDLE.

• Thonny is a beginner‑friendly IDE with a clean UI and a step‑through debugger. It’s another great choice if you’re just getting started. See Thonny: The Beginner‑Friendly Python Editor to learn more.

• PyCharm is a full‑featured IDE from JetBrains (Windows, macOS, Linux) with powerful refactoring, debugging, testing, and database and web tools. See PyCharm for Productive Python Development (Guide) for a comprehensive guide.

• Spyder is a scientific Python IDE with an IPython console, variable explorer, plots, and NumPy, pandas, and Matplotlib integrations. It’s popular in data science workflows.

If you’re into data science, then you may use JupyterLab, which isn’t a traditional IDE but is widely used for data analysis and teaching.

This list isn’t exhaustive. If you’re new, start with Thonny. For larger projects and web work, PyCharm is a strong choice. Explore and experiment before you make your final choice.

AI Coding Assistants

AI coding assistants can augment your workflow by generating code, explaining error messages, writing tests and documentation, and suggesting refactors. All of this comes from natural language prompts. Most popular and powerful AI coding assistants like GitHub Copilot Chat, Claude Code, Codex CLI, Gemini CLI, and JetBrains AI Assistant, are available as editor plugins or extensions, web apps, and command-line tools.

When you’re using these AI assistants, keep these best practices in mind:

• Be specific in your prompts: Include your Python version and library names and versions when they matter.
• Verify everything: Run the code, read the documentation, and add tests.
• Protect secrets: Don’t share user credentials, private keys, or sensitive data in prompts.
• Treat it like a junior teammate: You’re still the engineer responsible for code correctness and style.

AI assistants are tools to speed up your development process. They’re not replacements for understanding. Use them for learning, coding, and automating routine tasks, but always validate their output and keep building your understanding of Python and the libraries you use.

The Standard Library

One of the great things about Python is the plethora of available modules, packages, and libraries built into the Python core and made available by third-party developers. These modules, packages, and libraries can be very useful in your day-to-day work as a Python developer.

Here are some of the most commonly used built-in modules:

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 the pow() function:

>>> 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 needing 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 unexpected behavior.

The Python Package Index (PyPI)

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, uv, or another package installer.

New coders frequently hit a wall when they’re following an example and get a ModuleNotFoundError exception when they run the code. This error means that the code lives in a module, but that module isn’t installed in the current Python environment, leading to a broken dependency.

For example, say you’re trying to run an application that uses pandas, but you don’t have this library installed in your Python environment. In this situation, you can open your terminal and use pip as shown below:

$ python -m pip 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. If there are no other broken dependencies, the code will work.