La science des données transforme le marché actuel de manière inimaginable. Depuis qu'il a commencé à prospérer, il n'a cessé de s'affiner et est devenu l'outil le plus indispensable pour les organisations de tous les secteurs. De l'analyse des comportements des clients à la prédiction des tendances du marché, la science des données offre aux entreprises des informations puissantes qui peuvent les aider à prendre de meilleures décisions et à acquérir un avantage concurrentiel dans leurs secteurs respectifs.

Python pour la science des données

Python est un langage de programmation polyvalent et convivial qui offre une variété de bibliothèques et d'outils pour l'intelligence artificielle, l'apprentissage automatique et l'analyse de données. Son vaste écosystème de bibliothèques comprend des modules bien connus tels que NumPy, Pandas, Matplotlib, Scikit-learn et TensorFlow, qui sont souvent utilisés par les scientifiques des données pour créer des modèles de données et des visualisations complexes. Outre ses capacités techniques, il dispose également d'une communauté importante et solidaire qui contribue continuellement à sa croissance et à son développement. En raison de tout ce qu'il a à offrir, les scientifiques des données peuvent acquérir un avantage concurrentiel en maîtrisant Python avant d'entrer dans l'industrie.

Concepts essentiels lors de l'apprentissage des principes de base de Python

A.Types de données

Bien que Python soit un langage à typage dynamique dans lequel les types de données sont déterminés lors de l'exécution, il est toujours essentiel de connaître les différences entre les types de données car il détermine les opérations pouvant être effectuées sur une variable donnée.

Types de données de base en Python

1. Numérique

Entiers vs flottants

Un entier est simplement un nombre entier tandis qu'un nombre à virgule flottante , ou float , est un nombre composé de décimales. Cela fait de la valeur 11 un entier et de la valeur décimale 2,5 un flottant.

L'utilisation de la fonction type () vous aiderait à le confirmer.

num = 11
print(f"num is a \"{type(num)}\"")

decimal = 1.1
print(f"decimal is a \"{type(decimal)}\"")

Les chaînes sont des valeurs textuelles composées d'une séquence de caractères (lettres, chiffres et autres caractères valides).

name = "S@r4!1l"
print(f"name is a \"{type(name)}\"")

Les booléens sont utilisés pour stocker les valeurs logiques "True" et "False" . Ces valeurs sont souvent vues dans des instructions conditionnelles car elles sont utilisées pour contrôler le flux de la programmation.

found = True
print(f"found is a \"{type(found)}\"")

1. Liste

Les listes sont des collections ordonnées d'éléments mutable , ce qui signifie que l'objet peut être modifié après avoir été créé. Il est créé à l'aide de crochets [] où tous ses éléments sont à l'intérieur séparés par une virgule.

Par exemple,

colors = ["Red", "Yellow", "Blue"]

empty_list = []
print(f"empty_list is a \"{type(empty_list)}\"")

Les tuples sont des collections ordonnées d'éléments qui sont immutables , ce qui signifie que l'objet ne peut pas être modifié après sa création. Il est créé à l'aide de parenthèses () où tous ses éléments sont à l'intérieur séparés par une virgule.

Par exemple,

fruits = ("Mango", "Pineapple", "Strawberry")

empty_tuple = ()
print(f"empty_tuple is a \"{type(empty_tuple)}\"")

Dictionnaires mutable collection ordonnée d'éléments qui n'autorise aucun doublon. Il se compose de paires clé-valeur à l'intérieur d'accolades {} où un deux-points ( :) est utilisé pour séparer les clés de sa valeur correspondante.

Par exemple,

my_dict = {1:'a', 2:'b', 3:'c', 4:'d', 5:'e', 6:'f', 7:'g', 8:'h', 9:'i', 10:'j', 11:'k', 12:'l', 13:'m', 14:'n', 15:'o', 16:'p', 17:'q', 18:'r', 19:'s', 20:'t', 21:'u', 22:'v', 23:'w', 24:'x', 25:'y', 26:'z'}

empty_dict = {}
print(f"empty_dict is a \"{type(empty_dict)}\"")

Les ensembles sont des collections modifiables non ordonnées de données uniques qui n'autorisent aucun doublon. Il est créé à l'aide d'accolades {} où tous ses éléments sont à l'intérieur séparés par une virgule.

Par exemple,

even = {2, 4, 6, 8, 10}

empty_set = set()
print(f"empty_set is a \"{type(empty_set)}\"")

Le flux de contrôle d'un programme est la séquence dans laquelle les instructions sont évaluées et exécutées. La séquence peut être modifiée en fonction des instructions de flux de contrôle utilisées. La maîtrise de ce concept permet aux programmeurs d'effectuer des opérations complexes et d'écrire du code lisible et maintenable.

Énoncés de sélection

1. Si déclaration

Si les instructions sont utilisées pour exécuter un corps de code lorsque certaines conditions sont remplies. La syntaxe d'une instruction if est :

if condition:
    # code to be executed if True

if grade > 75 and grade <= 100:
    print("Passed")

Une condition else peut être ajoutée après une instruction if . La syntaxe d'une instruction if-else est :

if condition:
    # code to be executed if True 
else:
    # code to be executed if False

if grade > 75 and grade <= 100:
    print("Passed")
else:
    print("Failed")

L'ajout d'un mot-clé elif permet plusieurs alternatives. La syntaxe d'une instruction if-elif-else est :

if condition1:
    # code to be executed if condition1 is True 
elif condition2:
    # code to be executed if condition2 is True
else:
    # code to be executed when both condition1 and condition2 are False

if grade > 75 and grade <= 100:
    print("Passed")
elif grade == 0:
    print("Incomplete")
else:
    print("Failed")

1. Pour la boucle

Les boucles for sont utilisées pour parcourir un objet itérable tel qu'une chaîne, une liste ou un tuple. Ci-dessous, nous allons créer une boucle qui parcourt une liste de noms et imprimera chaque élément de la liste.

for name in name_list:
    print(name)

Les boucles While sont utilisées pour exécuter un bloc de code jusqu'à ce que certaines conditions soient remplies. Ci-dessous, nous allons créer une boucle qui imprime la valeur de i jusqu'à ce qu'elle atteigne 5.

while i <= 5:
    print(i)
    i += 1

Les fonctions sont des blocs de code réutilisables qui exécutent une tâche spécifique. Cela permet aux programmeurs de décomposer leurs solutions en tâches spécifiques, d'éviter la répétition de codes et de maintenir des programmes lisibles.

La syntaxe de déclaration d'une fonction en Python peut être la suivante :

# without parameters
def function_name1():
    # function body 

# with parameters
def function_name2(parameter):
    # function body

def greeting(name):
    print(f"Hello {name}!")

Voici comment c'est fait :

greeting("Mary")

La programmation orientée objet (POO) est une approche de l'écriture de programmes informatiques dans laquelle les classes d'objets sont étroitement liées aux attributs (variables) et aux comportements (méthodes) auxquels elles sont associées. Comprendre la POO permet de mieux comprendre les bibliothèques Python et nous permet de créer des programmes maintenables et lisibles.

Quatre piliers de la POO

1. Héritage

L'héritage est la dérivation d'une nouvelle classe à partir d'une classe existante. Cette nouvelle classe (également appelée classe enfant) hérite des méthodes et des propriétés d'une classe existante (appelée classe parent).

Prenons un exemple,

# Parent class
class Fruit:
    def __init__(self, name, price):
        self.name = name
        self.price = price

# Child class 
class Mango:
    def __init__(self, name, price, state):
        # Access methods and properties of the parent class using super()
        super().__init__(name, price)
        self.state = state

2. Encapsulation

L'encapsulation est le regroupement d'attributs et de méthodes connexes dans une seule classe. Grâce à l'encapsulation , les classes externes ne peuvent pas modifier les attributs et les méthodes disponibles pour une classe. En effet, les variables sont généralement rendues "privées" pour masquer les données.

En Python, les attributs privés sont indiqués à l'aide de doubles traits de soulignement ( __ ).

Un exemple serait,

class Fruit:
    def __init__(self, name):
        self.name = name
        self.__price = 10

    def sell(self, payment):
        print(f"Selling price: {self.__price}")
        print(f"Change: {payment - self.__price}")

    def set_price(self, price):
        self.__price = price

orange = Fruit("orange")
orange.sell(12)

# Changing the price
orange.__price = 5
orange.sell(12)

# Using the setter method
orange.set_price(3)
orange.sell(12)

3. Polymorphisme

Le polymorphisme est l'utilisation d'une seule entité pour effectuer différents types de comportements. Disons que nous avons l'exemple ci-dessous :

class Cat:
    def make_sound(self):
        print("Meow")

class Frog:
    def make_sound(self):
        print("Ribbit")

class Cow:
    def make_sound(self):
        print("Moo")

4. Abstraction

L'abstraction consiste à cacher des détails sans importance à l'utilisateur pour réduire la complexité du programme et s'assurer que les programmeurs se concentrent uniquement sur ceux qui sont importants.

Voici un exemple de sa mise en œuvre,

from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def drive(self):
        pass

class Car(Vehicle):
    def drive(self):
        print("Driving a car")

class Motorcycle(Vehicle):
    def drive(self):
        print("Driving a motorcycle")

#vehicle = Vehicle()
car = Car()
motorcycle = Motorcycle()

#vehicle.drive()
car.drive()
motorcycle.drive()

Conclusion

En résumé, l'acquisition d'une base solide des fondamentaux de Python est vitale pour les personnes qui aspirent à entrer dans le domaine de la science des données. Python est un langage de programmation très approprié pour la science des données en raison de sa nature conviviale, de ses bibliothèques étendues, de sa polyvalence et de sa communauté de soutien. De plus, l'utilisation généralisée de Python dans le domaine crée de nombreuses opportunités de carrière pour ceux qui le maîtrisent. Par conséquent, l'apprentissage des bases de Python peut devenir une étape cruciale vers une carrière réussie en science des données pour les futurs professionnels de la science des données.