Maison >développement back-end >Tutoriel Python >Python : du débutant au professionnel (partie 3)
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):
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 :
Exemples réels :
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
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"):
Que se passe-t-il à l'intérieur de la fonction :
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
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 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.
When deciding which data structure to use, consider these factors:
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!