Python : du débutant au professionnel (partie 3)

Fonctions en Python

Les fonctions sont des blocs de code réutilisables qui effectuent une tâche spécifique. Ils aident à organiser votre code, à le rendre plus lisible et à réduire les répétitions. Prenez, par exemple, l'écriture de codes qui peuvent devenir si longs et très difficiles à lire ou trouver ce que fait chaque ligne, principalement lorsque vous devez appeler une valeur.

    def greet(name):

Pourquoi utiliser des fonctions ?

Imaginez que vous préparez un repas complexe. Au lieu d'essayer de tout faire en même temps, vous décomposez le processus en tâches plus petites : hacher les légumes, préparer la sauce, cuire le plat principal, etc. Chacune de ces tâches pourrait être considérée comme une fonction en programmation.

Chacun a mis une section qui peut être appelée quand nous en avons besoin sans avoir à encombrer tout le repas avec tout le code, ce qui rend notre code plus facile à lire et moins d'erreurs.

Les fonctions nous permettent de :

• Organiser le code : Tout comme l'organisation des ingrédients et des étapes d'une recette, les fonctions nous aident à organiser notre code en parties logiques et gérables.
• Réutiliser le code : si vous devez effectuer la même tâche plusieurs fois, vous pouvez créer une fonction et l'appeler chaque fois que nécessaire, plutôt que d'écrire le même code encore et encore.
• Simplifiez les tâches complexes : les problèmes importants peuvent être décomposés en éléments plus petits et plus gérables.
• Améliorer la lisibilité : les fonctions bien nommées rendent le code plus facile à comprendre, comme des instructions claires dans une recette.

Exemples réels :

• Application Calculatrice : Chaque opération (ajouter, soustraire, multiplier, diviser) peut être une fonction distincte.
• Publication sur les réseaux sociaux : les fonctions peuvent gérer la publication de texte, le téléchargement d'images ou l'ajout de hashtags.
• Achats en ligne : les fonctions peuvent calculer le coût total, appliquer des remises ou traiter les paiements.

Voyons maintenant comment créer et définir une fonction :

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

Décomposer cela

• def dit à Python que nous définissons une fonction.
• greet est le nom de la fonction (vous pouvez changer le nom comme vous le souhaitez !)
• (Alex) est le paramètre - un espace réservé pour les données que la fonction recevra

Le bloc en retrait est le corps de la fonction - ce que fait la fonction.

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

Utiliser (appeler) une fonction

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


greet("Alex"):

• C'est nous qui "appelons" ou "utilisons" la fonction.
• Nous disons : "Hé, fonction nommée 'greet', veuillez prendre 'Alex' comme entrée."
• "Alex" est l'argument. C'est comme donner à la fonction une information spécifique avec laquelle travailler.

Que se passe-t-il à l'intérieur de la fonction :

• La fonction prend "Alex" et le place là où se trouve {name} dans le message d'accueil.

• Cela crée donc le message : "Bonjour, Alex ! Bienvenue dans la programmation Python."

  message = ... :

• Nous stockons ce que la fonction renvoie (renvoie) dans une variable appelée 'message'.

• Alors maintenant, « message » contient le texte « Bonjour, Alex ! Bienvenue dans la programmation Python. »

  imprimer(message):

• Cela affiche simplement le contenu du « message » à l'écran.

« Cela afficherait : « Bonjour, Alex ! Bienvenue dans la programmation Python. »
Ici, "Alex" est un argument : les données réelles que nous transmettons à la fonction.

Exemple plus complexe :
Créons une fonction qui calcule le coût total des articles dans un panier :

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}")

Dans cet exemple, j'ai exploré plus d'un argument dans lequel j'ai placé items et tax_rate comme arguments dans notre fonction et j'ai défini des paramètres clairs à suivre pour notre fonction.

• subtotal = sum(items) - tandis que le sous-total est une variable ou un espace réservé pour la valeur qu'il calcule, qui est la somme (rappelez-vous que sum est une bibliothèque en Python qui renvoie la somme d'une valeur « de départ » (par défaut : 0) plus un itérable de nombres) d'éléments.

• tax = subtotal * tax_rate ici, nous prenons tax comme nouvelle variable, et dans cette variable, nous disons de prendre la variable précédente subtotal(sum(items)) * tax_rate, qui est un espace réservé pour tout chiffre que l'utilisateur indique.

• total = sous-total + taxe ; c'est la somme des deux variables, sous-total et taxe.

Une fois que nous avons appelé la fonction calculate_total(cart, tax) , le panier additionnera toutes les valeurs du panier (10,99+5,50+8,99), puis nous multiplierons la valeur par 0,08 pour obtenir la taxe, puis les additionnerons pour obtenir le total.

Notre instruction d'impression utilise une chaîne formatée, puis nous avons dit que total_cost devrait être réduit à une décimale de 2f.

Points clés à noter

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

• Avez-vous besoin de maintenir l’ordre ? Si oui, envisagez des listes ou des tuples.
• Avez-vous besoin de modifier la collection ? Si oui, utilisez des listes ou des dictionnaires.
• Devez-vous garantir l’unicité ? Si oui, utilisez des ensembles.
• Avez-vous besoin d'associer des valeurs à des clés ? Si oui, utilisez des dictionnaires.
• Avez-vous besoin d’une séquence immuable ? Si oui, utilisez des tuples.

Comprendre ces structures de données et quand et comment les utiliser vous aidera à écrire un code plus efficace et plus lisible. Au fur et à mesure que vous gagnerez en expérience, vous développerez une intuition pour savoir quelle structure correspond le mieux à vos besoins spécifiques.

N'oubliez pas que la flexibilité de Python vous permet d'effectuer des conversions entre ces structures en cas de besoin. Par exemple, vous pouvez convertir une liste en ensemble pour supprimer les doublons, puis la reconvertir en liste si vous devez maintenir l'ordre. Cette interopérabilité rend ces structures de données encore plus puissantes lorsqu'elles sont utilisées en combinaison.

Comment fait-on cela ? Découvrez-le et publiez-le sur la session de commentaires de notre groupe d'apprentissage Python.

En maîtrisant les listes, les ensembles, les tuples et les dictionnaires, vous disposerez d'une base solide pour gérer diverses tâches de manipulation de données en Python. Au fur et à mesure que vous progressez dans votre parcours de programmation, vous découvrirez des structures de données encore plus spécialisées, mais ces quatre resteront des outils fondamentaux dans votre boîte à outils de programmation Python.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!