Panduan teknikal untuk melaksanakan pembangunan modular skrip Python dalam sistem Linux

Panduan Teknikal untuk Melaksanakan Pembangunan Modular Skrip Python dalam Sistem Linux

Pengenalan:
Python adalah mudah dan mudah dipelajari dan Bahasa pengaturcaraan peringkat tinggi yang berkuasa, digunakan secara meluas dalam pembangunan dalam pelbagai bidang. Dalam sistem Linux, pembangunan modular skrip Python boleh meningkatkan kebolehselenggaraan dan kebolehgunaan semula kod secara berkesan serta mengurangkan kos pembangunan dan penyelenggaraan. Artikel ini akan memperkenalkan garis panduan teknikal tentang cara menggunakan Python untuk melaksanakan pembangunan modular dalam sistem Linux, dan menyediakan contoh kod khusus.

1. Gambaran keseluruhan pembangunan modular
Pembangunan modular adalah untuk membahagikan program besar kepada modul yang kecil, saling bergantung, dan berkomunikasi serta berinteraksi melalui antara muka antara modul. Ia membolehkan pembangun menumpukan pada reka bentuk dan pelaksanaan setiap modul, meningkatkan kebolehbacaan dan kebolehselenggaraan kod. Untuk skrip Python, modul boleh menjadi fungsi, kelas atau fail skrip bebas.

2. Buat modul

1. Buat fail modul bebas
   Dalam sistem Linux, kita boleh mentakrifkannya dengan mencipta fail skrip Python bebas sebuah modul. Sebagai contoh, kami mencipta fail bernama "utils.py", yang mentakrifkan beberapa fungsi alat yang biasa digunakan, seperti berikut:

# 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. Import module#🎜🎜 #In other Skrip Python, kita boleh menggunakan kata kunci import untuk mengimport modul yang telah ditentukan untuk digunakan dalam skrip semasa. Sebagai contoh, kami mencipta skrip bernama "main.py". Jika kami ingin menggunakan fungsi yang ditakrifkan dalam "utils.py", kami boleh mengimport dan memanggilnya dengan cara berikut:
   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()

< ol start=" 3">

Module data enkapsulasi

Dalam modul, sebagai tambahan kepada fungsi, kita juga boleh mentakrifkan pembolehubah dan kelas serta mengaksesnya melalui modul. Ini membantu merangkum data dan tingkah laku yang berkaitan dalam modul. Sebagai contoh, kami mentakrifkan pemalar dan kelas dalam "utils.py":

$ python3 utils.py

Ia boleh digunakan dalam skrip lain seperti berikut: rrreee

3 . Organisasi Fail Modul

Untuk projek besar, satu modul mungkin tidak mencukupi. Sebagai contoh, kami mencipta direktori yang dipanggil "kalkulator" dan meletakkan "utils.py" dan "main.py" di dalamnya.

rrreee
1. Dalam sistem Linux, anda boleh menjalankan skrip "main.py" dengan cara berikut:
rrreee
2. 4. Ujian modul
Semasa proses pembangunan, kami Modul selalunya perlu diuji. Python menyediakan beberapa rangka kerja dan alatan untuk ujian unit. Sebagai contoh, kita boleh menulis kes ujian menggunakan pustaka unittest dan menambah if __name__ == "__main__": keadaan dalam modul untuk dilaksanakan apabila modul dijalankan secara terus ujian .

rrreee#🎜🎜#Dalam sistem Linux, kami boleh menjalankan ujian dengan cara berikut: #🎜🎜#rrreee#🎜🎜#Ringkasan: #🎜🎜# Menggunakan skrip Python untuk pembangunan modular dalam sistem Linux boleh meningkatkan kebolehselenggaraan Kod dan kebolehgunaan semula. Artikel ini memperkenalkan penciptaan modul, mengimport modul, enkapsulasi data modul, organisasi fail modul dan ujian modul. Melalui amalan dan amalan berterusan, pembangun boleh menjadi lebih mahir dalam menggunakan skrip Python untuk pembangunan modular, meningkatkan kecekapan pembangunan dan kualiti kod. #🎜🎜##🎜🎜#Rujukan: #🎜🎜##🎜🎜##🎜🎜#dokumentasi rasmi Python: https://www.python.org/#🎜🎜##🎜🎜#Python : dokumentasi unittest: https://www.python.org/#🎜🎜## //docs.python.org/3/library/unittest.html#🎜🎜##🎜🎜#

Atas ialah kandungan terperinci Panduan teknikal untuk melaksanakan pembangunan modular skrip Python dalam sistem Linux. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!