Home > Posts > Beginner's Guide to Python

Beginner's Guide to Python

  ·   18 min read

Introduction to Python #

What is Python and why learn it? #

Python is a high-level, general-purpose programming language known for its clear syntax and readability. It’s incredibly versatile, used in web development, data science, machine learning, scripting, automation, and much more. Its beginner-friendliness makes it an excellent language to start your programming journey.

Why learn Python?

  • Readability: Python’s syntax is designed to be easily understood, resembling plain English. This makes it easier to learn, write, and maintain code.
  • Versatility: Its vast libraries and frameworks allow you to tackle diverse programming tasks. Whether you’re building a website or analyzing data, Python likely has the tools you need.
  • Large Community: A huge and active community provides ample support, resources, and readily available solutions to common problems.
  • Extensive Libraries: Python boasts a rich ecosystem of libraries, offering pre-built functions and modules for various tasks, significantly reducing development time. Examples include NumPy for numerical computation and Pandas for data manipulation.
  • High Demand: Python developers are in high demand across many industries. Learning Python can open doors to exciting career opportunities.

Setting up your Python environment #

Before you can start writing Python code, you need to set up a Python environment on your computer. Here’s a step-by-step guide:

  1. Download Python: Go to the official Python website (python.org) and download the latest version of Python for your operating system (Windows, macOS, or Linux). Make sure to select the appropriate installer for your system (32-bit or 64-bit).

  2. Install Python: Run the downloaded installer and follow the on-screen instructions. During installation, it’s generally recommended to add Python to your system’s PATH environment variable. This allows you to run Python from your command line or terminal without specifying the full path to the Python executable.

  3. Verify the Installation: Open your command line or terminal and type python --version or python3 --version (depending on your system’s configuration). If Python is installed correctly, you’ll see the version number printed.

  4. (Optional) Choose an IDE or Text Editor: While you can write Python code in any plain text editor, using an Integrated Development Environment (IDE) like VS Code, PyCharm, or Thonny can significantly enhance your development experience. These IDEs offer features such as syntax highlighting, code completion, debugging tools, and more.

Hello, world! Your first Python program. #

The traditional first program in any programming language is the “Hello, world!” program. In Python, it’s incredibly simple:

print("Hello, world!")

To run this program:

  1. Open a text editor or IDE.
  2. Type the code above.
  3. Save the file with a .py extension (e.g., hello.py).
  4. Open your command line or terminal.
  5. Navigate to the directory where you saved the file.
  6. Type python hello.py and press Enter.

You should see “Hello, world!” printed on the console. Congratulations, you’ve written and run your first Python program! This simple example introduces the print() function, a fundamental building block in Python used to display output to the user.

Basic Syntax and Data Types #

Variables and Assignment #

In Python, variables are used to store data. Unlike many other languages, Python doesn’t require you to explicitly declare the data type of a variable; the type is inferred at runtime. You assign a value to a variable using the = operator.

name = "Alice"  # String variable
age = 30       # Integer variable
height = 5.8   # Float variable
is_student = True # Boolean variable

Variable names must start with a letter or underscore and can contain letters, numbers, and underscores. They are case-sensitive (e.g., age and Age are different variables). It’s good practice to use descriptive variable names that clearly indicate the data they store.

Data Types: Integers, Floats, Strings, Booleans #

Python supports several fundamental data types:

  • Integers (int): Represent whole numbers without decimal points (e.g., 10, -5, 0).

  • Floats (float): Represent numbers with decimal points (e.g., 3.14, -2.5, 0.0).

  • Strings (str): Represent sequences of characters, enclosed in single (’ ‘) or double (" “) quotes (e.g., “Hello”, ‘Python’).

  • Booleans (bool): Represent truth values, either True or False.

You can check the data type of a variable using the type() function:

print(type(name))   # Output: <class 'str'>
print(type(age))    # Output: <class 'int'>
print(type(height)) # Output: <class 'float'>
print(type(is_student)) # Output: <class 'bool'>

Operators: Arithmetic, Comparison, Logical #

Python provides a variety of operators to perform different operations:

  • Arithmetic Operators:

    • + (addition)
    • - (subtraction)
    • * (multiplication)
    • / (division)
    • // (floor division – integer division)
    • % (modulo – remainder after division)
    • ** (exponentiation)

  • Comparison Operators:

    • == (equal to)
    • != (not equal to)
    • > (greater than)
    • < (less than)
    • >= (greater than or equal to)
    • <= (less than or equal to)

  • Logical Operators:

    • and (logical AND)
    • or (logical OR)
    • not (logical NOT)

Example:

x = 10
y = 5

print(x + y)       # Output: 15
print(x > y)       # Output: True
print(x == y)      # Output: False
print(x > 5 and y < 10) # Output: True

Basic Input and Output #

  • Output: The print() function is used to display output to the console.

  • Input: The input() function is used to get input from the user. The input is always read as a string.

name = input("Enter your name: ")
age = int(input("Enter your age: ")) # Convert input string to integer

print("Hello,", name + "! You are", age, "years old.")

This code first prompts the user to enter their name and age. The input() function reads the input as strings. The age is then converted to an integer using int() before being used in the output. Note the use of commas within the print() function; this allows you to print multiple items separated by spaces.

Control Flow #

Conditional Statements: if, elif, else #

Conditional statements allow you to execute different blocks of code based on certain conditions. Python uses if, elif (else if), and else keywords to create conditional statements.

age = 20

if age < 18:
    print("You are a minor.")
elif age >= 18 and age < 65:
    print("You are an adult.")
else:
    print("You are a senior citizen.")

The code evaluates the conditions sequentially. If a condition is True, the corresponding block of code is executed, and the rest of the if-elif-else structure is skipped. If none of the conditions are True, the else block (if present) is executed. Indentation is crucial in Python; it defines the code blocks associated with each condition.

Loops: for and while loops #

Loops allow you to repeatedly execute a block of code. Python offers two main types of loops: for and while.

  • for loop: Iterates over a sequence (like a list, tuple, string, or range) or other iterable object.
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

for i in range(5): # range(5) generates numbers 0, 1, 2, 3, 4
    print(i)
  • while loop: Repeats a block of code as long as a condition is True.
count = 0
while count < 3:
    print(count)
    count += 1

It’s important to ensure that the condition in a while loop eventually becomes False to avoid infinite loops.

Break and Continue Statements #

break and continue statements modify the execution flow within loops:

  • break: Terminates the loop prematurely. Execution continues with the statement immediately following the loop.
for i in range(5):
    if i == 3:
        break
    print(i) # Output: 0 1 2
  • continue: Skips the rest of the current iteration and proceeds to the next iteration.
for i in range(5):
    if i == 2:
        continue
    print(i) # Output: 0 1 3 4

break and continue can be used in both for and while loops to control their execution based on specific conditions. They are powerful tools for creating more flexible and efficient loops.

Data Structures #

Lists #

Lists are ordered, mutable (changeable) sequences of items. They can contain items of different data types. Lists are defined using square brackets [].

my_list = [1, "hello", 3.14, True]
print(my_list)       # Output: [1, 'hello', 3.14, True]
print(my_list[0])    # Output: 1 (accessing the first element)
my_list.append(5)    # Adding an element to the end
my_list.insert(2, "world") # Inserting "world" at index 2
print(my_list)       # Output: [1, 'hello', 'world', 3.14, True, 5]
del my_list[1]      # Deleting the element at index 1
print(my_list)       # Output: [1, 'world', 3.14, True, 5]

Lists support various methods for manipulating their contents, such as append(), insert(), remove(), pop(), sort(), etc.

Tuples #

Tuples are ordered, immutable (unchangeable) sequences of items. They are defined using parentheses ().

my_tuple = (1, "hello", 3.14, True)
print(my_tuple)     # Output: (1, 'hello', 3.14, True)
print(my_tuple[0])  # Output: 1
# my_tuple[0] = 2  # This will raise a TypeError because tuples are immutable

Because tuples are immutable, they are often used to represent fixed collections of data.

Dictionaries #

Dictionaries are unordered collections of key-value pairs. Keys must be immutable (e.g., strings, numbers, tuples), while values can be of any data type. Dictionaries are defined using curly braces {}.

my_dict = {"name": "Alice", "age": 30, "city": "New York"}
print(my_dict)      # Output: {'name': 'Alice', 'age': 30, 'city': 'New York'}
print(my_dict["name"]) # Output: Alice (accessing the value associated with the key "name")
my_dict["age"] = 31   # Modifying a value
my_dict["country"] = "USA" # Adding a new key-value pair
print(my_dict)      # Output: {'name': 'Alice', 'age': 31, 'city': 'New York', 'country': 'USA'}

Dictionaries provide efficient lookups based on keys.

Sets #

Sets are unordered collections of unique items. They are defined using curly braces {} or the set() constructor.

my_set = {1, 2, 3, 3, 4} # Duplicates are automatically removed
print(my_set)      # Output: {1, 2, 3, 4}
my_set.add(5)      # Adding an element
my_set.remove(2)   # Removing an element
print(my_set)      # Output: {1, 3, 4, 5}

Sets support operations like union (|), intersection (&), difference (-), etc., making them useful for tasks involving set theory. The order of elements in a set is not guaranteed.

Functions #

Defining Functions #

Functions are blocks of reusable code that perform specific tasks. They improve code organization, readability, and reusability. You define a function using the def keyword, followed by the function name, parentheses (), and a colon :. The function body is indented.

def greet(name):
    print("Hello,", name + "!")

greet("Alice")  # Calling the function

This defines a function named greet that takes one argument (name) and prints a greeting.

Function Arguments and Parameters #

Arguments are the values passed to a function when it’s called. Parameters are the variables listed in the function definition that receive the argument values.

def add(x, y):  # x and y are parameters
    return x + y

result = add(5, 3)  # 5 and 3 are arguments
print(result)      # Output: 8

Functions can have multiple parameters, or no parameters at all. You can also use default parameter values:

def greet(name, greeting="Hello"): #greeting has a default value
    print(greeting, name + "!")

greet("Bob")       # Output: Hello Bob!
greet("Charlie", "Good morning") # Output: Good morning Charlie!

Return Values #

Functions can return values using the return statement. If a function doesn’t have a return statement, it implicitly returns None.

def square(x):
    return x * x

result = square(4)
print(result)  # Output: 16

def no_return():
    print("This function doesn't return anything.")

print(no_return()) # Output: This function doesn't return anything. None

Scope and Lifetime of Variables #

The scope of a variable determines where in your code it’s accessible. The lifetime of a variable is the duration for which it exists in memory.

  • Local Scope: Variables defined inside a function have local scope. They are only accessible within that function.

  • Global Scope: Variables defined outside any function have global scope. They are accessible from anywhere in the program.

global_var = 10  # Global variable

def my_function():
    local_var = 5  # Local variable
    print("Inside function:", global_var, local_var) #Both accessible here

my_function() # Output: Inside function: 10 5
print("Outside function:", global_var)  # Output: Outside function: 10
#print(local_var) # This will raise a NameError because local_var is not accessible outside the function

A local variable’s lifetime is the duration of the function call. A global variable’s lifetime is the entire execution of the program. It’s good practice to minimize the use of global variables to enhance code clarity and avoid potential conflicts.

Modules and Packages #

Importing Modules #

Modules are files containing Python code (functions, classes, variables). They promote code reusability and organization. You import modules using the import statement.

import math

result = math.sqrt(25)  # Using the sqrt() function from the math module
print(result)          # Output: 5.0

import random
random_number = random.randint(1, 10) #Using randint from random module
print(random_number)

You can also import specific functions or variables from a module:

from math import pi, pow

print(pi)       # Output: 3.141592653589793
print(pow(2, 3)) # Output: 8.0

Using from module import * imports everything from the module, but this is generally discouraged because it can lead to naming conflicts. It’s better to explicitly import what you need.

Using Built-in Modules #

Python comes with many built-in modules providing various functionalities. Some commonly used built-in modules include:

  • math: Mathematical functions (e.g., sqrt(), sin(), cos(), log())
  • random: Random number generation (e.g., randint(), random(), choice())
  • os: Operating system related functions (e.g., file manipulation, directory navigation)
  • sys: System-specific parameters and functions
  • datetime: Date and time manipulation
  • string: String operations

Installing External Packages Using pip #

pip is Python’s package installer. It allows you to install and manage third-party packages (collections of modules) from the Python Package Index (PyPI) and other repositories.

To install a package, open your command line or terminal and use the following command:

pip install <package_name>

For example, to install the requests library (for making HTTP requests):

pip install requests

After installation, you can import and use the package in your Python code:

import requests

response = requests.get("https://www.example.com")
print(response.status_code) # Output: 200 (if successful)

pip also allows you to upgrade, uninstall, and manage other aspects of your installed packages. Use pip help to see all the available commands. Many IDEs also offer integrated package management tools that simplify the process.

Working with Files #

Opening and Closing Files #

In Python, you work with files using the built-in open() function. The open() function takes the file path as the first argument and a mode as the second argument. Common modes include:

  • "r": Read mode (default). Opens the file for reading. The file must exist.
  • "w": Write mode. Opens the file for writing. If the file exists, its contents are overwritten. If it doesn’t exist, a new file is created.
  • "a": Append mode. Opens the file for writing. New data is appended to the end of the file. If the file doesn’t exist, a new file is created.
  • "x": Exclusive creation mode. Creates a new file. If the file already exists, an error is raised.

It’s crucial to always close a file after you’re finished with it using the close() method. This releases the file resources.

file = open("my_file.txt", "r") #opens file in read mode
# ... process the file ...
file.close()

A more robust approach is to use a with statement. This ensures the file is automatically closed, even if errors occur:

with open("my_file.txt", "r") as file:
    # ... process the file ...  #file is automatically closed here, even if exception occurs.

Reading from Files #

Once you’ve opened a file in read mode, you can read its contents using various methods:

  • read(): Reads the entire file content as a single string.
  • readline(): Reads a single line from the file.
  • readlines(): Reads all lines from the file and returns them as a list of strings.
with open("my_file.txt", "r") as file:
    content = file.read()  # Reads the entire file
    print(content)

with open("my_file.txt", "r") as file:
    line = file.readline() #reads the first line
    print(line)
    while line: #continues reading until end of file is reached
        line = file.readline()
        print(line)

with open("my_file.txt", "r") as file:
    lines = file.readlines() #reads all lines into a list
    for line in lines:
        print(line, end="") #end="" prevents extra newline

Writing to Files #

To write to a file, open it in write ("w") or append ("a") mode. Use the write() method to write strings to the file.

with open("my_file.txt", "w") as file:
    file.write("This is the first line.\n")
    file.write("This is the second line.\n")

with open("my_file.txt", "a") as file: #appends to existing file
    file.write("This line is appended.\n")

Remember that writing to a file in write mode ("w") will overwrite any existing content. Use append mode ("a") if you want to add to the end of an existing file. The \n character adds a newline to create separate lines in the file.

Object-Oriented Programming (OOP) #

Classes and Objects #

Object-Oriented Programming (OOP) is a programming paradigm that organizes code around “objects” rather than functions and logic. An object is a data field that has unique attributes and behavior. A class is a blueprint for creating objects.

class Dog:  # Define a class named Dog
    def __init__(self, name, breed):  # Constructor (special method) to initialize object attributes
        self.name = name              # Attribute: dog's name
        self.breed = breed            # Attribute: dog's breed

    def bark(self):                   # Method: dog's behavior
        print("Woof!")

my_dog = Dog("Buddy", "Golden Retriever")  # Create an object (instance) of the Dog class
print(my_dog.name)                     # Access an attribute
my_dog.bark()                           # Call a method

another_dog = Dog("Lucy", "Labrador")
print(another_dog.breed)

The __init__ method is a special method called the constructor. It’s automatically called when you create a new object. self refers to the instance of the class.

Methods and Attributes #

Methods are functions defined within a class. They operate on the object’s data (attributes). Attributes are variables that hold the object’s data.

class Cat:
    def __init__(self, name, color):
        self.name = name
        self.color = color
        self.age = 0  #default age

    def meow(self):
        print("Meow!")

    def birthday(self):
        self.age +=1
        print(f"{self.name} is now {self.age} years old.")

my_cat = Cat("Whiskers", "gray")
my_cat.meow()
my_cat.birthday()
my_cat.birthday()

Inheritance and Polymorphism #

Inheritance allows you to create new classes (child classes) based on existing classes (parent classes). The child class inherits attributes and methods from the parent class and can add its own.

Polymorphism allows objects of different classes to respond to the same method call in their own specific way.

class Animal: #parent class
    def __init__(self, name):
        self.name = name

    def speak(self):
        print("Generic animal sound")

class Dog(Animal): #child class inheriting from Animal
    def speak(self):
        print("Woof!")

class Cat(Animal): #another child class inheriting from Animal
    def speak(self):
        print("Meow!")

animals = [Dog("Buddy"), Cat("Whiskers")]
for animal in animals:
    animal.speak() #Polymorphism: different classes respond differently to speak()

Here, Dog and Cat inherit from Animal. The speak() method is polymorphic; it behaves differently depending on the object’s class. This demonstrates the power of OOP in creating flexible and extensible code.

Error Handling #

Try-Except Blocks #

Errors (exceptions) can occur during program execution. try-except blocks handle exceptions gracefully, preventing program crashes.

try:
    result = 10 / 0  # This will cause a ZeroDivisionError
except ZeroDivisionError:
    print("Error: Division by zero!")
except Exception as e: #catches other exceptions
    print(f"An error occurred: {e}")
else: #executes if no exception occurs in try block
    print("Division successful:", result)
finally: #always executes, regardless of exception
    print("This always executes.")

The try block contains the code that might raise an exception. If an exception occurs, the corresponding except block is executed. The else block (optional) executes only if no exception occurs in the try block. The finally block (optional) always executes, regardless of whether an exception occurred or not; it’s often used for cleanup actions (like closing files).

Common Exceptions #

Python has many built-in exceptions. Some common ones include:

  • ZeroDivisionError: Division by zero.
  • TypeError: Operation on incompatible types.
  • NameError: Using an undefined variable.
  • IndexError: Accessing an index out of range in a sequence (list, tuple, string).
  • FileNotFoundError: Trying to open a non-existent file.
  • ValueError: Incorrect value passed to a function.
  • IOError: Input/output error.

Raising Exceptions #

You can explicitly raise exceptions using the raise keyword. This is useful for signaling errors in your own code.

def validate_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative.")
    elif age > 120:
        raise ValueError("Age is unreasonably high.")
    return age

try:
    age = validate_age(-5)
    print("Valid age:", age)
except ValueError as e:
    print("Error:", e)

Raising exceptions allows you to create custom error handling for your functions and applications, making your code more robust and easier to debug. It helps separate error-handling logic from the main program flow, making the code more readable and maintainable.

Next Steps #

Where to Learn More #

This beginner’s guide provides a foundation in Python. To deepen your understanding and explore more advanced topics, consider these resources:

  • Official Python Documentation: The official Python documentation (docs.python.org) is an invaluable resource. It’s comprehensive and well-organized, covering everything from basic syntax to advanced concepts.

  • Online Courses: Platforms like Coursera, edX, Udemy, and Codecademy offer numerous Python courses for all skill levels, from beginner to advanced. Look for courses that focus on specific areas of interest, such as web development, data science, or machine learning.

  • Interactive Tutorials: Websites like LearnPython.org provide interactive tutorials that allow you to practice coding directly in your browser.

  • Books: Many excellent Python books are available, catering to different learning styles and experience levels. Look for books that cover the specific areas of Python you want to learn more about.

  • YouTube Channels: Many YouTube channels offer Python tutorials and explanations of complex concepts.

Practice Projects #

The best way to learn Python is by practicing. Here are some project ideas to get you started:

  • Simple Calculator: Build a command-line calculator that performs basic arithmetic operations.

  • Number Guessing Game: Create a game where the computer generates a random number, and the user has to guess it.

  • To-Do List Application: Develop a simple to-do list application that allows users to add, remove, and mark tasks as complete.

  • Basic Web Scraper: Learn to scrape data from websites using libraries like Beautiful Soup and requests.

  • Text-Based Adventure Game: Create a text-based adventure game where the user interacts with the story through text commands.

Start with small projects and gradually increase the complexity as your skills improve. Remember to break down larger projects into smaller, manageable tasks.

Contributing to Open Source #

Contributing to open-source projects is a great way to learn from experienced developers, gain practical experience, and build your portfolio.

  • Find Projects: Websites like GitHub and GitLab host thousands of open-source Python projects. Look for projects that align with your interests and skill level. Start with projects that have good documentation and a welcoming community.

  • Start Small: Begin by fixing simple bugs, improving documentation, or adding minor features. Don’t try to tackle large, complex tasks right away.

  • Follow Guidelines: Most open-source projects have contribution guidelines. Follow these guidelines carefully to ensure your contributions are accepted.

  • Learn Git: Git is a version control system essential for collaborating on open-source projects. Learn the basics of Git before you start contributing.

Contributing to open source is a valuable learning experience that will significantly enhance your programming skills. It also allows you to give back to the community that has helped you learn.

←
Beginner's Guide to TypeScript
Beginner's Guide to JavaScript
→
back to top