Python: From Beginners to Pro (Part 3)

Functions in Python

Functions are reusable blocks of code that perform a specific task. They help organize your code, make it more readable, and reduce repetition. Take, for example, writing codes that can become so long and very hard to read or find what each line does, mostly when you have to call value.

    def greet(name):

Why Use Functions?

Imagine you're cooking a complex meal. Instead of trying to do everything at once, you break the process down into smaller tasks: chopping vegetables, preparing the sauce, cooking the main dish, etc. Each of these tasks could be thought of as a function in programming.

Each put in a section that can be called when we need it without having to clog the whole meal with all the code, making our code easier to read and less error.

Functions allow us to:

• Organize Code: Just like organizing ingredients and steps in a recipe, functions help us organize our code into manageable, logical parts.
• Reuse Code: If you need to perform the same task multiple times, you can create a function and call it whenever needed, rather than writing the same code over and over.
• Simplify Complex Tasks: Large problems can be broken down into smaller, more manageable pieces.
• Improve Readability: Well-named functions make code easier to understand, like clear instructions in a recipe.

Real-Life Examples:

• Calculator App: Each operation (add, subtract, multiply, divide) could be a separate function.
• Social Media Post: Functions could handle posting text, uploading images, or adding hashtags.
• Online Shopping: Functions might calculate total cost, apply discounts, or process payments.

Now, let's look at how to create and define a Function:

def greet(name):
    """
    This function takes a name and returns a greeting message.
    """
    return f"Hello, {name}! Welcome to Python programming."

Breaking this down

• def tells Python we're defining a function.
• greet is the function name (you can change the name to whatever you want!)
• (Alex) is the parameter - a placeholder for the data the function will receive

The indented block is the function body - what the function does.

return specifies what the function gives back when it's done

Using (Calling) a Function

# Calling the function
message = greet("Alex")
print(message)


greet("Alex"):

• This is us "calling" or "using" the function.
• We're saying, "Hey, function named 'greet', please take 'Alex' as the input."
• "Alex" is the argument. It's like giving the function a specific piece of information to work with.

What happens inside the function:

• The function takes "Alex" and puts it where {name} is in the greeting.

• So it creates the message: "Hello, Alex! Welcome to Python programming."

  message = ...:

• We're storing what the function gives back (returns) in a variable called 'message'.

• So now 'message' contains the text "Hello, Alex! Welcome to Python programming."

  print(message):

• This simply displays the contents of 'message' on the screen.

“This would output: "Hello, Alex! Welcome to Python programming.”
Here, "Alex" is an argument - the actual data we're passing to the function.

More Complex Example:
Let's create a function that calculates the total cost of items in a shopping cart:

def calculate_total(items, tax_rate):
    subtotal = sum(items)
    tax = subtotal * tax_rate
    total = subtotal + tax
    return total

    # Using the function
    cart = [10.99, 5.50, 8.99]
    tax = 0.08  # 8% tax
    total_cost = calculate_total(cart, tax)
    print(f"Your total including tax is: ${total_cost:.2f}")

In this example, I explored more than one argument where I placed items and tax_rate as arguments in our function and made some clear parameters for our function to follow.

• subtotal = sum(items) - while subtotal is a variable or placeholder for the value it calculates, which is the sum (remember sum is a library in Python that returns the sum of a 'start' value (default: 0) plus an iterable of numbers) of items.

• tax = subtotal * tax_rate here, we are taking tax as a new variable, and in that variable, we are saying take the previous variable subtotal(sum(items)) * tax_rate, which is a placeholder for any figure the user puts in.

• total = subtotal + tax; this is the sum of the two variables, subtotal and tax.

Once we call the function calculate_total(cart, tax) , the cart will sum all the values in the cart (10.99+5.50+8.99), and then we multiply the value by 0.08 to get the tax and then add them together to get the total.

Our print statement uses a formatted string, and then we said the total_cost should be reduced to a 2f decimal place.

Key Points to Note

• Function Names: Use clear, descriptive names. calculate_total is better than calc or function1.
• Parameters: These are the inputs your function expects. In calculate_total, we have two: items and tax_rate.
• Return Statement: This specifies what the function gives back. Not all functions need to return something, but many do.
• Indentation: Everything inside the function must be indented. This is how Python knows what's part of the function.
• Calling the Function: We use the function name followed by parentheses containing the arguments.

Practice Exercise:
Try creating a function that takes a person's name and age, and returns a message like "Hello [name], you will be [age+10] in 10 years." This will help you practice using multiple parameters and doing calculations within a function.

Python Data Structures: Lists, Sets, Tuples, and Dictionaries

Python offers several built-in data structures that allow programmers to organize and manipulate data efficiently. we'll explore four essential data structures: lists, sets, tuples, and dictionaries. Each of these structures has unique characteristics and use cases.

Lists
Lists are the most commonly used data structure in Python. They are ordered, mutable collections that can contain elements of different data types. You can create a list using square brackets:

fruits = ["apple", "banana", "cherry"]

Lists maintain the order of elements, allowing you to access them by their index. For example, fruits[0] would return "apple". This ordering makes lists ideal for situations where the sequence of elements matters, such as maintaining a playlist or a to-do list.

One of the key advantages of lists is their mutability. You can easily add, remove, or modify elements:

fruits.append("date")  # Adds "date" to the end
fruits[1] = "blueberry"  # Replaces "banana" with "blueberry"

Lists also support various operations like slicing, concatenation, and list comprehensions, making them extremely versatile. Use lists when you need an ordered collection that you can modify and when you want to allow duplicate elements.

To learn more about lists, check this guide by Bala Priya C (Lists in Python – A Comprehensive Guide)

Sets
Sets are unordered collections of unique elements. You can create a set using curly braces or the set() function.

unique_numbers = {1, 2, 3, 4, 5}

The defining feature of sets is that they only store unique elements. If you try to add a duplicate element, it will be ignored. This makes sets perfect for removing duplicates from a list or for membership testing.

Sets also support mathematical set operations like union, intersection, and difference:

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.union(set2))  # {1, 2, 3, 4, 5}

While sets are mutable (you can add or remove elements), they must be immutable. Use sets when you need to ensure uniqueness of elements and don't care about their order.

To learn more about sets, check this guide on w3school

Tuples
Tuples are similar to lists in that they are ordered sequences, but they are immutable – once created, they cannot be modified. You create a tuple using parentheses:

coordinates = (10, 20)

The immutability of tuples makes them useful for representing fixed collections of items, like the x and y coordinates in our example. They're also commonly used to return multiple values from a function.

def get_user_info():
    return ("Alice", 30, "New York")

name, age, city = get_user_info()

Tuples can be used as dictionary keys (unlike lists) because of their immutability. Use tuples when you have a collection of related items that shouldn't change throughout your program's execution.

If you need more insight on tuples, Geeksforgeeks has a very informative guide on it

Dictionaries: Key-Value Pairs
Dictionaries are unordered collections of key-value pairs. They provide a way to associate related information. You create a dictionary using curly braces with key-value pairs:

person = {"name": "Alex", "age": 25, "city": "San Francisco"}

Dictionaries allow fast lookup of values based on their keys. You can access, add, or modify values using their associated keys:

 print(person["name"])  # Prints "Alex"
 person["job"] = "Engineer"  # Adds a new key-value pair

Dictionaries are incredibly useful for representing structured data, similar to JSON. They're also great for counting occurrences of items or creating mappings between related pieces of information.

I love what Simplilearn did with this guide on dictionary; find it here.

Choosing the Right Data Structure

When deciding which data structure to use, consider these factors:

• Do you need to maintain order? If yes, consider lists or tuples.
• Do you need to modify the collection? If yes, use lists or dictionaries.
• Do you need to ensure uniqueness? If yes, use sets.
• Do you need to associate values with keys? If yes, use dictionaries.
• Do you need an immutable sequence? If yes, use tuples.

Understanding these data structures and when and how to use them will help you write more efficient and readable code. As you gain experience, you'll develop an intuition for which structure best fits your specific needs.

Remember, Python's flexibility allows you to convert between these structures when needed. For example, you can convert a list to a set to remove duplicates and then convert it back to a list if you need to maintain order. This interoperability makes these data structures even more powerful when used in combination.

How do we do this? Find out and post it on the comment session of our Python learning group.

By mastering lists, sets, tuples, and dictionaries, you'll have a solid foundation for handling various data manipulation tasks in Python. As you progress in your programming journey, you'll discover even more specialized data structures, but these four will remain fundamental tools in your Python programming toolkit.

The above is the detailed content of Python: From Beginners to Pro (Part 3). For more information, please follow other related articles on the PHP Chinese website!