Guide technique pour la mise en œuvre du développement modulaire de scripts Python dans les systèmes Linux

Guide technique pour la mise en œuvre du développement modulaire de scripts Python dans les systèmes Linux

Introduction :
Python est un langage de programmation de haut niveau facile à apprendre et puissant, largement utilisé dans le développement dans différents domaines. Dans les systèmes Linux, le développement modulaire de scripts Python peut améliorer efficacement la maintenabilité et la réutilisation du code et réduire les coûts de développement et de maintenance. Cet article présentera des directives techniques sur la façon d'utiliser Python pour implémenter le développement modulaire dans les systèmes Linux et fournira des exemples de code spécifiques.

1. Présentation du développement modulaire
Le développement modulaire consiste à diviser un grand programme en petits modules interdépendants, et à communiquer et interagir via les interfaces entre les modules. Il permet aux développeurs de se concentrer sur la conception et la mise en œuvre de chaque module, améliorant ainsi la lisibilité et la maintenabilité du code. Pour les scripts Python, un module peut être une fonction, une classe ou un fichier de script indépendant.

2. Créer un module

1. Créer un fichier de module indépendant
   Dans les systèmes Linux, nous pouvons définir un module en créant un fichier de script Python indépendant. Par exemple, nous créons un fichier nommé "utils.py", qui définit certaines fonctions d'outils couramment utilisées, comme indiqué ci-dessous :

# utils.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    return a / b

2. Module d'importation
   Dans d'autres scripts Python, nous pouvons utiliser import mot-clé pour importer des modules déjà définis à utiliser dans le script actuel. Par exemple, nous créons un script nommé "main.py". Si nous voulons utiliser les fonctions définies dans "utils.py", nous pouvons les importer et les appeler de la manière suivante : <code>import 关键字来导入已经定义好的模块，以便在当前脚本中使用。例如，我们创建一个名为"main.py"的脚本，想要使用"utils.py"中定义的函数，可以通过以下方式导入并调用：

# main.py

import utils

print(utils.add(1, 2))        # 输出：3
print(utils.subtract(5, 2))   # 输出：3
print(utils.multiply(2, 3))   # 输出：6
print(utils.divide(10, 2))    # 输出：5

3. 模块的资料封装
   在模块中，除了函数之外，我们还可以定义变量和类，并通过模块访问它们。这有助于将相关的数据和行为封装在一个模块中。例如，我们在"utils.py"中定义一个常量和一个类：

# utils.py

PI = 3.1415926

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return PI * self.radius ** 2

    def circumference(self):
        return 2 * PI * self.radius

在其他脚本中可以如下使用：

# main.py

import utils

print(utils.PI)                         # 输出：3.1415926

circle = utils.Circle(5)
print(circle.area())                     # 输出：78.5398185
print(circle.circumference())            # 输出：31.415926

三、模块的文件组织
对于大型项目，一个模块可能不够，我们可以将相关的模块组织在同一个目录中，并提供一个入口文件。例如，我们创建一个名为"calculator"的目录，并将"utils.py"和"main.py"放在其中。

# calculator/utils.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

...

# calculator/main.py

import utils

...

在Linux系统中，可以通过以下方式运行"main.py"脚本：

$ python3 calculator/main.py

四、模块的测试
在开发过程中，我们经常需要对模块进行测试。Python提供了一些用于单元测试的框架和工具。例如，我们可以使用unittest库编写测试用例，并在模块中添加一个if __name__ == "__main__":

# utils.py

...

def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为0")
    return a / b

if __name__ == "__main__":
    import unittest

    class UtilsTestCase(unittest.TestCase):
        def test_add(self):
            self.assertEqual(add(1, 2), 3)
        
        def test_subtract(self):
            self.assertEqual(subtract(5, 2), 3)
        
        def test_multiply(self):
            self.assertEqual(multiply(2, 3), 6)
        
        def test_divide(self):
            self.assertEqual(divide(10, 2), 5)
            self.assertRaises(ValueError, divide, 10, 0)

    unittest.main()

du module Encapsulation des données

Dans un module, en plus des fonctions, on peut également définir des variables et des classes et y accéder via le module. Cela permet d'encapsuler les données et les comportements associés dans un module. Par exemple, nous définissons une constante et une classe dans "utils.py" :




$ python3 utils.py

Elle peut être utilisée dans d'autres scripts comme suit :

rrreee

3. Organisation des fichiers du module
Pour les grands projets, un module peut ne pas suffire , nous pouvons organiser les modules associés dans le même répertoire et fournir un fichier d'entrée. Par exemple, nous créons un répertoire appelé « calculatrice » et y plaçons « utils.py » et « main.py ».
1. rrreee
Dans le système Linux, vous pouvez exécuter le script "main.py" de la manière suivante :
2. rrreee
4 Test du module
Pendant le processus de développement, nous devons souvent tester le module. Python fournit plusieurs frameworks et outils pour les tests unitaires. Par exemple, nous pouvons écrire des cas de test en utilisant la bibliothèque unittest et ajouter une condition if __name__ == "__main__": dans le module à exécuter lorsque le module est exécuté directement pour tester . 🎜rrreee🎜Dans les systèmes Linux, nous pouvons exécuter des tests des manières suivantes : 🎜rrreee🎜Résumé : 🎜L'utilisation de scripts Python pour le développement modulaire dans les systèmes Linux peut améliorer la maintenabilité et la réutilisabilité du code. Cet article présente la création de modules, l'importation de modules, l'encapsulation des données des modules, l'organisation des fichiers des modules et les tests des modules. Grâce à une pratique et une pratique continues, les développeurs peuvent devenir plus compétents dans l'utilisation des scripts Python pour le développement modulaire, améliorant ainsi l'efficacité du développement et la qualité du code. 🎜🎜Matériaux de référence : 🎜🎜🎜Documentation officielle Python : https://www.python.org/🎜🎜Documentation du test unitaire Python : https://docs.python.org/3/library/unittest.html🎜🎜

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!