21 March 2025

Python Basics: A Beginner's Guide to Coding

Python is a versatile and widely-used programming language, known for its clear syntax and readability. This makes it an ideal choice for beginners because it's used in everything from web development to data science, opening up many career paths. This article will guide you through fundamental Python concepts with simple, easy-to-understand code examples.

Your First Python Program: “Hello, World!”

Let's begin with the traditional “Hello, World!” program. In Python, this is exceptionally straightforward:

print("Hello, Beginner!")

This single line accomplishes the following:

  1. print(): This is a built-in function. Functions are reusable blocks of code that perform specific tasks. print() displays output to the user.
  2. ("Hello, Beginner!"): Inside the parentheses is a string literal. A string is a sequence of characters, enclosed in either single ('...') or double ("...") quotes.

When you run this, the Python interpreter executes print(), displaying “Hello, Beginner!” on your screen.

Variables in Python

Variables are crucial for storing data. Think of them as labeled containers. It's good practice to use descriptive names, start with lowercase letters, and use underscores to separate words (e.g., my_variable, user_age). Here's an example:

# Assigning values to variables
message = "Welcome to Python!"
number = 10
pi = 3.14159

# Printing the variable values
print(message)
print(number)
print(pi)

Explanation:

  1. message = "Welcome to Python!": A variable named message is created, storing the string "Welcome to Python!".
  2. number = 10: A variable named number stores the integer 10.
  3. pi = 3.14159: A variable named pi stores the floating-point number 3.14159.

print() then displays these values. Python is dynamically typed: you don't need to explicitly state the variable's type (string, integer, float). Python infers it from the assigned value.

User Interaction in Python

Interactive programs often need user input. Here's how to get it:

# Getting user input
name = input("Please enter your name: ")

# Printing a personalized greeting
print("Hello, " + name + "!")  # String concatenation

Explanation:

  1. name = input("Please enter your name: "): input() pauses the program, waits for the user to type something and press Enter, and stores it as a string in name.
  2. print("Hello, " + name + "!"): This prints a greeting. The + operator, with strings, performs string concatenation, joining them. It's good practice to add spaces around the + when concatenating for readability.

Conditional Logic: if, else, and elif

Conditional statements let your program make decisions, controlling which code blocks are executed based on conditions being true or false.

age = int(input("Enter your age: "))

if age >= 18:
    print("You are eligible to vote.")
elif age < 0:
    print("That is an incorrect age.")
else:
    print("You are not eligible to vote yet.")

Breakdown:

  1. age = int(input("Enter your age: ")): Takes user input for age. int() converts the input (a string by default) to an integer.
  2. if age >= 18:: Checks if age is greater than or equal to 18. If true, the indented print statement is executed.
  3. elif age < 0:: If the previous if condition is false, this condition will be checked. If it is true, then the corresponding block will be executed. elif stands for “else if” and allows for multiple conditions to be checked in sequence.
  4. else:: If none of the if or elif conditions are true, the indented code under else is executed. Indentation is vital in Python; it defines code blocks associated with if, elif, and else. Consistent indentation (usually 4 spaces) is crucial for Python code to work correctly.

Loops: Repeating Code with for

Loops repeat code blocks. The for loop iterates over a sequence (e.g., a list or a range of numbers).

# Printing numbers 0-4
for i in range(5):
    print(i)

# Printing list elements
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

Explanation:

  1. for i in range(5):: range(5) generates numbers from 0 up to (but not including) 5. The loop iterates through this sequence; in each iteration, the current number is assigned to i.
  2. for fruit in fruits:: This loop iterates through the fruits list. In each iteration, the current list element is assigned to fruit.

Loops: Repeating Code with while

The while loop continues as long as a condition is true.

count = 0
while count < 5:
    print(count)
    count += 1  # Increment count

Explanation:

  1. count = 0: Initializes count to 0.
  2. while count < 5:: The loop continues as long as count is less than 5.
  3. count += 1: Inside the loop, count is incremented by 1 in each iteration. This prevents an infinite loop (where the condition would always remain true).

Functions: Reusable Code Blocks

Functions are essential for code reuse, organization, and readability. Instead of repeating the same code multiple times, you can define a function once and call it whenever you need that specific functionality. Define your own using def.

# Defining a function
def greet(name):
    print("Hello, " + name + "!")

# Calling the function
greet("Alice")
greet("Bob")

Key points:

  1. def greet(name):: Defines a function named greet that takes one parameter called name.
  2. print("Hello, " + name + "!"): The function's body—the code executed when the function is called.
  3. greet("Alice"): Calls the greet function, passing “Alice” as the argument.

Combining Concepts: A Simple Area Calculator

Let's combine concepts into a slightly more complex program:

def calculate_area(length, width):
    """Calculates the area of a rectangle."""  # Docstring
    area = length * width
    return area

# Get dimensions
length = float(input("Enter length: "))
width = float(input("Enter width: "))

# Calculate area
rectangle_area = calculate_area(length, width)

# Print result
print("Area:", rectangle_area)

Explanation:

  1. def calculate_area(length, width):: Defines a function to calculate rectangle area, taking length and width as parameters. The """...""" is a docstring, describing the function. Docstrings are used for documentation and can be accessed by help() function.
  2. return area: The function returns the calculated area. The return statement exits the function and sends the value back to where the function was called.
  3. The program gets user input for length and width, converting them to floating-point numbers using float(). Using float() allows for decimal values, making the calculator more versatile.
  4. It calls calculate_area, passing in the dimensions, and storing the returned value in rectangle_area.
  5. Finally, it prints the area.

More Control Flow Tools

Python provides other tools for controlling program flow.

break, continue, and else in Loops

  • break: Exits the innermost enclosing for or while loop.
  • continue: Proceeds to the next iteration of the loop.
  • Loop else clause: In for, executed after the loop finishes (unless break occurred). In while, executed after the condition becomes false (unless break occurred).
#Example for break
numbers = [1, 2, 3, 4, 5]
for number in numbers:
    if number == 3:
        break  # Exit the loop when number is 3
    print(number)  # Output: 1 2

#Example for continue
numbers = [1, 2, 3, 4, 5]
for number in numbers:
    if number == 3:
        continue  # Skip to the next iteration when number is 3
    print(number)  # Output: 1 2 4 5

#Example for else
for i in range(5):
    print(i)
else:
    print("Loop finished") #It will be executed

for i in range(5):
    if i==3:
        break
    print(i)
else:
    print("Loop finished") #It won't be executed

The match Statement

match compares a value against patterns. It's like switch statements in other languages but with more powerful pattern-matching. This is available from Python 3.10.

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 401 | 403 | 404:  # Multiple cases
            return "Not allowed"
        case 418:
            return "I'm a teapot"
        case _:  # Default
            return "Something's wrong"

print(http_error(404))
print(http_error(500))

_ is a wildcard, matching anything if no other case matches.

Data Structures

Python has built-in data structures for organizing data.

  • Lists: Ordered, mutable (changeable) sequences.
my_list = [1, 2, 3, "apple"]
my_list.append("cherry")  # Add an element to the end
print(my_list[0])       # Access element by index (starting from 0)
my_list.remove(2)        # Remove an element by value
print(my_list)
  • Tuples: Ordered, immutable sequences.
my_tuple = (1, 2, 3, "apple")
# my_tuple[0] = 5  # Error (immutable) - Tuples cannot be modified after creation
print(my_tuple[1])
  • Sets: Unordered collections of unique elements.
my_set = {1, 2, 3, 3, 4, 5}  # Duplicates are automatically removed
print(my_set)  # Output: {1, 2, 3, 4, 5}
  • Dictionaries: Key-value pairs. Keys must be immutable (like strings, numbers, or tuples).
my_dict = {"name": "Alice", "age": 30}
print(my_dict["name"])  # Access value by key
my_dict["age"] = 31      # Modify a value
print(my_dict)
  • List Comprehensions: Concise syntax for creating lists.
squares = [x**2 for x in range(10)]      # List of squares
even = [x for x in range(20) if x % 2 == 0]  # Even numbers
print(squares)
print(even)

Modules

Modules organize code into reusable files. Use import to access functionality from other modules.

import math

print(math.sqrt(16))  # Access the sqrt function from the math module
print(math.pi)        # Access the pi constant

from math import sqrt  # Import specific function

print(sqrt(25))

from math import *  # Import all (generally avoid)

print(pi)

This demonstrates using the math module (which provides mathematical functions). Importing specific functions or constants can improve code readability and avoid naming conflicts. Importing everything with * is generally discouraged in larger projects.

Defining Functions: Advanced Techniques

Default Argument Values

Functions can have default values for arguments.

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

greet("Bob")           # Uses default greeting
greet("Alice", "Hi")  # Overrides default

Keyword Arguments

Call functions using keyword=value syntax.

def describe_pet(animal_type, pet_name):
    print("I have a " + animal_type + " named " + pet_name + ".")

describe_pet(pet_name="Harry", animal_type="hamster")  # Order doesn't matter

Arbitrary Argument Lists

Functions can accept an arbitrary number of positional arguments using *args.

def make_pizza(*toppings):
    print("Making a pizza with:")
    for topping in toppings:
        print("- " + topping)

make_pizza("pepperoni")
make_pizza("mushrooms", "cheese", "peppers")

*toppings collects all the positional arguments into a tuple named toppings.

Arbitrary Keyword Arguments

Functions can accept an arbitrary number of keyword arguments using **kwargs.

def build_profile(first, last, **kwargs):
    # Combines fixed and arbitrary keyword arguments to create a user profile.
    profile = {'first_name': first, 'last_name': last}
    profile.update(kwargs)  # Updates profile with key-value pairs from kwargs.
    return profile

user = build_profile("Albert", "Einstein", location="Princeton", field="physics")
print(user)  # Output: {'first_name': 'Albert', 'last_name': 'Einstein', 'location': 'Princeton', 'field': 'physics'}

**kwargs stands for “keyword arguments” and is a common naming convention for collecting additional named arguments into a dictionary. This allows functions to handle flexible inputs.

Lambda Expressions

Small, anonymous functions created with lambda.

add = lambda x, y: x + y
print(add(5, 3))  # Output: 8

pairs = [(1, 'one'), (2, 'two'), (3, 'three')]
pairs.sort(key=lambda pair: pair[1]) #sort by second element of tuple
print(pairs)

Lambda functions are often used as arguments to higher-order functions (functions that take other functions as arguments), like sort in this example.

Classes

Classes provide a way to bundle data (attributes) and functionality (methods) that operate on that data. It's one of the main features in object-oriented programming, allowing you to create blueprints for objects.

class Dog:
    def __init__(self, name, age): #constructor
        self.name = name
        self.age = age

    def bark(self):
        print("Woof!")

my_dog = Dog("Buddy", 3) #instance of class
print(my_dog.name)
my_dog.bark()

Explanation:

  • class Dog:: Defines a class named Dog.
  • def __init__(self, name, age):: This is the constructor (or initializer). It's called automatically when you create a new Dog object.
    • self: Refers to the instance of the class (the specific Dog object you're working with). It's the first parameter in all methods within a class.
  • def bark(self):: This is a method—a function that belongs to the Dog class. It can access the dog's data (like self.name, though it doesn't in this simple example).
  • my_dog = Dog("Buddy", 3) Creates a instance of the Dog class named my_dog.

Iterators

An iterator is an object that allows to traverse through all the elements of a collection, regardless of its specific implementation.

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    x = self.a
    self.a += 1
    return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))

Generators

Generators are a type of iterable, like lists or tuples. Unlike lists, they don't store their contents in memory, generating values on the fly, using the keyword yield. This makes them memory-efficient for large sequences. This also makes them distinct from list comprehensions, which create the entire list in memory.

def my_generator():
  yield 1
  yield 2
  yield 3

for value in my_generator():
  print(value)

#generator expression
squares = (x*x for x in range(10))
print(list(squares))

These fundamentals provide a solid base for your Python journey. By experimenting with these concepts and combining them, you can build increasingly sophisticated programs. Remember that practice and exploration are key to mastering any programming language.

Related News

Related Articles