Jour de #daysofMiva || Maîtriser les modules Python, JSON, les mathématiques et les dates

C'est le jour n°14 et je suis de retour là où j'ai laissé mes simples projets python avant de m'enfuir vers flask. Mdr! Le codage peut être passionnant, et parfois frustrant aussi (ou c'est le cas la plupart du temps...). Quoi qu'il en soit, vous le savez mieux grâce à vos expériences. C'est pourquoi je suis ravi de documenter le mien. Alors aujourd'hui, j'ai appris les modules Python, le polymorphisme, JSON, Math, Datetime, Scope et les itérateurs. Allons-y.

1. Modules Python : créer des bibliothèques de codes réutilisables

Les modules en Python sont des fichiers contenant du code Python (fonctions, variables ou classes) qui peuvent être réutilisés dans différents scripts ou projets. La création de modules favorise la réutilisation du code, rendant vos projets plus propres et plus modulaires.

Création et importation de modules :

Un module est simplement un fichier Python enregistré avec l'extension .py. Vous pouvez définir des fonctions, des variables et des classes dans un module et les importer dans un autre.

Exemple : Création et utilisation d'un module

1. Créez un fichier appelé mymodule.py avec le contenu suivant :

# mymodule.py
def greeting(name):
    print(f"Hello, {name}")

1. Maintenant, importez le module dans un autre script Python :

import mymodule

mymodule.greeting("Jonathan")  # Output: Hello, Jonathan

Vous pouvez également donner un alias à un module lors de l'import :

import mymodule as mx

mx.greeting("Jane")  # Output: Hello, Jane

Utilisation des modules intégrés :

Python est livré avec de nombreux modules intégrés. Par exemple, vous pouvez utiliser le module plateforme pour récupérer les informations système :

import platform

print(platform.system())  # Output: The OS you're running (e.g., Windows, Linux, etc.)

2. Travailler avec JSON en Python : analyse et génération de données JSON

JSON (JavaScript Object Notation) est largement utilisé pour transmettre des données dans les applications Web. Python fournit le module json pour analyser et générer du JSON.

Analyse JSON :

Vous pouvez convertir une chaîne JSON en dictionnaire Python à l'aide de json.loads().

import json

json_data = '{ "name": "John", "age": 30, "city": "New York" }'
parsed_data = json.loads(json_data)

print(parsed_data['age'])  # Output: 30

Conversion d'objets Python en JSON :

Vous pouvez également convertir des objets Python (par exemple, dict, liste, tuple) en chaîne JSON à l'aide de json.dumps().

Exemple :

import json

python_obj = {"name": "John", "age": 30, "city": "New York"}
json_string = json.dumps(python_obj)

print(json_string)  # Output: {"name": "John", "age": 30, "city": "New York"}

Formatage et personnalisation de la sortie JSON :

Vous pouvez rendre la chaîne JSON plus lisible en utilisant le paramètre indent :

json_string = json.dumps(python_obj, indent=4)
print(json_string)

Cela génère une chaîne JSON bien formatée :

{
    "name": "John",
    "age": 30,
    "city": "New York"
}

3. Python Math : effectuer des opérations mathématiques

Python fournit à la fois des fonctions intégrées et le module mathématique pour effectuer diverses tâches mathématiques.

Fonctions mathématiques de base :

min() et max() : Pour trouver les valeurs minimales et maximales dans un itérable :

print(min(5, 10, 25))  # Output: 5
print(max(5, 10, 25))  # Output: 25

abs() : renvoie la valeur absolue d'un nombre :

print(abs(-7.25))  # Output: 7.25

pow() : Calcule la puissance d'un nombre :

print(pow(4, 3))  # Output: 64 (4 to the power of 3)

Le module Mathématiques :

Pour les opérations mathématiques avancées, le module mathématique offre un ensemble complet de fonctions.

• Racine carrée : Utilisation de math.sqrt() :

import math

print(math.sqrt(64))  # Output: 8.0

• Plafond et Sol : Arrondit un nombre vers le haut ou vers le bas :

print(math.ceil(1.4))  # Output: 2
print(math.floor(1.4))  # Output: 1

• PI Constante : Accéder à la valeur de π :

print(math.pi)  # Output: 3.141592653589793

4. Travailler avec des dates : gérer le temps en Python

Le module datetime de Python permet de gérer les dates et les heures. Vous pouvez générer la date actuelle, extraire des composants spécifiques (comme l'année, le mois, le jour) ou manipuler des objets date.

Obtention de la date et de l'heure actuelles :

La fonction datetime.now() renvoie la date et l'heure actuelles.

import datetime

current_time = datetime.datetime.now()
print(current_time)
# Output: 2024-09-06 05:15:51.590708 (example)

Création d'une date spécifique :

Vous pouvez créer une date personnalisée à l'aide du constructeur datetime().

custom_date = datetime.datetime(2020, 5, 17)
print(custom_date)  # Output: 2020-05-17 00:00:00

Formatage des dates avec strftime() :

Vous pouvez formater des objets date en chaînes à l'aide de strftime().

Exemple :

formatted_date = custom_date.strftime("%B %d, %Y")
print(formatted_date)  # Output: May 17, 2020

Voici un tableau de quelques codes de format courants utilisés dans strftime() :

Polymorphism in Python

Polymorphism refers to the ability of different objects to be treated as instances of the same class through a common interface. It allows methods to do different things based on the object it is acting upon.

Method Overriding
In Python, polymorphism is often achieved through method overriding. A subclass can provide a specific implementation of a method that is already defined in its superclass.

Example:

class Animal:
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"

# Using polymorphism
def animal_sound(animal):
    print(animal.make_sound())

dog = Dog()
cat = Cat()

animal_sound(dog)  # Output: Woof!
animal_sound(cat)  # Output: Meow!

In the above example, animal_sound() can handle both Dog and Cat objects because they both implement the make_sound() method, demonstrating polymorphism.

Operator Overloading

Polymorphism also allows you to define how operators behave with user-defined classes by overloading them.

Example:

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(2, 3)
v2 = Vector(4, 1)
v3 = v1 + v2

print(v3)  # Output: Vector(6, 4)
Here, the + operator is overloaded to handle Vector objects, allowing us to add vectors using the + operator.

2. Iterators in Python
An iterator is an object that allows you to traverse through a container, such as a list or tuple, and retrieve elements one by one. Python iterators implement two main methods: __iter__() and __next__().

Creating an Iterator
You can create your own iterator by defining a class with __iter__() and __next__() methods.

Example:

python
Copy code
class CountDown:
    def __init__(self, start):
        self.start = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.start <= 0:
            raise StopIteration
        current = self.start
        self.start -= 1
        return current

# Using the iterator

cd = CountDown(5)
for number in cd:
    print(number)
# Output: 5, 4, 3, 2, 1

In this example, CountDown is an iterator that counts down from a starting number to 1.

Using Built-in Iterators
Python provides built-in iterators such as enumerate(), map(), and filter().

Example:

numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x ** 2, numbers)

for num in squared:
    print(num)
# Output: 1, 4, 9, 16, 25

Here, map() applies a function to all items in the list and returns an iterator.

Scope in Python

Scope determines the visibility of variables in different parts of the code. Python uses the LEGB rule to resolve names: Local, Enclosing, Global, and Built-in.

Local Scope

Variables created inside a function are local to that function.

Example:

def my_func():
    x = 10  # Local variable
    print(x)

my_func()
# Output: 10

Here, x is accessible only within my_func().

Global Scope

Variables created outside any function are global and accessible from anywhere in the code.

Example:

Copy code
x = 20  # Global variable

def my_func():
    print(x)

my_func()
print(x)
# Output: 20, 20

Enclosing Scope

In nested functions, an inner function can access variables from its enclosing (outer) function.

Example:

def outer_func():
    x = 30

    def inner_func():
        print(x)  # Accessing variable from outer function

    inner_func()

outer_func()
# Output: 30

Global Keyword

To modify a global variable inside a function, use the global keyword.

Example:

x = 50

def my_func():
    global x
    x = 60

my_func()
print(x)
# Output: 60

Nonlocal Keyword

The nonlocal keyword allows you to modify a variable in the nearest enclosing scope that is not global.

Example:

def outer_func():
    x = 70

    def inner_func():
        nonlocal x
        x = 80

    inner_func()
    print(x)

outer_func()
# Output: 80

In this example, nonlocal allows inner_func() to modify the x variable in outer_func().

Check out my #100daysofMiva repo on GitHub. Follow, Star and Share.

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!