Tìm hiểu về Module trong Python

Module là một file chứa các định nghĩa và lệnh Python, cho phép bạn tổ chức mã nguồn thành các khối logic. Bài viết này mình sẽ chia sẻ cho bạn các thông tin cơ bản về khái niệm module, cách module hoạt động và một số ví dụ cụ thể.

Module trong Python là gì?

Module trong Python là một file chứa code Python, có thể bao gồm các định nghĩa về hàm, lớp, biến và các đối tượng khác. Module giúp chia nhỏ và tổ chức code thành các phần có chức năng riêng biệt, làm cho code dễ quản lý, dễ tái sử dụng và dễ bảo trì hơn.

Ví dụ

Để thấy rõ cách module hoạt động, xem qua ví dụ sử dụng một module có tên random (module này thường có sẵn trong Python) để tạo một số ngẫu nhiên.

import random

# In ra 1 số nguyên ngẫu nhiên trong khoảng 1 đến 10
print("Số ngẫu nhiên từ 1 đến 10:", random.randint(1, 10))
#In ra 1 số thập phân ngẫu nhiên từ 0 đến 1
print ("Số thập phân ngẫu nhiên từ 0 đến 1", random.random())

Khi chạy đoạn code, bạn sẽ thấy kết quả sau:

Module do người dùng định nghĩa trong Python

Trong Python, bất kỳ file văn bản nào có phần mở rộng .py và chứa mã Python đều được xem là một module. Đây là nơi bạn có thể định nghĩa một hoặc nhiều hàm (function), biến (variable), hằng số (constant) hoặc thậm chí là các lớp (class). Để sử dụng các đối tượng (object) trong một module ở một phiên làm việc trình thông dịch (interpreter session) hoặc trong một script Python khác, chúng ta cần sử dụng lệnh import. Một module cũng có thể chứa các đoạn code có thể thực thi.

Các module được tích hợp sẵn trong Python

Python có một thư viện chuẩn rất phong phú, đi kèm với vô số các module. Các module này được gọi là các module tích hợp sẵn. Hầu hết các module này được viết bằng ngôn ngữ C (vì Python được viết dựa trên C), và được biên dịch trước thành thư viện. Các module tích hợp sẵn này chứa các chức năng rất hữu ích, bao gồm quản lý hệ điều hành, thao tác I/O trên ổ đĩa, mạng,…

Dưới đây là danh sách một số module tích hợp sẵn phổ biến:

Tạo module trong Python

Việc tạo ra một module trong Python thực sự đơn giản, chỉ là việc lưu code Python vào một tệp. Hãy cùng tạo một module đơn giản bằng cách lưu đoạn code sau vào tệp có tên my_module.py (bạn có thể chọn tên khác nếu muốn):

def thong_bao(message):
    print("Thông báo:", message)

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

Bạn có thể sử dụng module vừa tạo ở phiên làm việc của Python hoặc trong một script khác bằng cách sử dụng lệnh import. Ví dụ, bạn hãy mở Python terminal và làm theo các bước sau:

>>> import my_module
>>> my_module.thong_bao("Chào mừng bạn đến với Python!")
Thông báo: Chào mừng bạn đến với Python!
>>> print(my_module.tinh_tong(5, 3))
8

Ngoài ra, chúng ta hoàn toàn có thể dùng một module ở một file Python script khác. Bạn hãy tạo thêm file vi_du.py và ghi nội dung sau vào:

import my_module

my_module.thong_bao("Python thật tuyệt vời!")
ket_qua = my_module.tinh_tong(10, 2)
print("Kết quả:", ket_qua)

Bây giờ bạn hãy chạy vi_du.py trên command line:

python vi_du.py

Kết quả:

Câu lệnh import trong Python

Trong Python, từ khóa import cho phép chúng ta nạp các đối tượng (object) từ một module (module) khác. Đối tượng ở đây có thể là một hàm (function), một lớp (class), hoặc một biến (variable),… Khi một module có nhiều định nghĩa bên trong, tất cả chúng sẽ được nạp vào không gian tên (namespace) hiện tại.

Ví dụ

Chúng ta sẽ tạo một module có tên là calculator.py có 3 hàm: tính tổng, tính trung bình, tính lũy thừa

# calculator.py

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

def tinh_trung_binh(a, b):
   return (a + b) / 2

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

Câu lệnh import calculator sẽ nạp tất cả các hàm vào trong không gian tên của chương trình hiện tại, chúng ta sẽ truy cập các function đó thông qua module object (chính là calculator). Để kiểm tra các thuộc tính của module calculator vừa import ta dùng hàm dir()

>>> import calculator
>>> dir(calculator)
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'tinh_luy_thua', 'tinh_tong', 'tinh_trung_binh']

Như bạn thấy ở trên, trong calculator module object chúng ta có thể thấy các thuộc tính là các function chúng ta đã định nghĩa trước đó, chúng ta có thể truy cập chúng theo cú pháp tên_module.tên_function. Tiếp theo, chúng ta sẽ tạo file main.py và dùng module calculator

# main.py
import calculator

print ("Tổng:", calculator.tinh_tong(10, 20))
print ("Trung bình:", calculator.tinh_trung_binh(10, 20))
print ("Lũy thừa:", calculator.tinh_luy_thua(10, 2))

Khi chạy file main.py ta được kết quả như sau:

Lệnh from … import

Lệnh import thông thường sẽ tải toàn bộ tài nguyên của một module vào không gian tên hiện tại. Tuy nhiên, đôi khi bạn chỉ cần sử dụng một vài đối tượng cụ thể (như hàm, biến, class) từ module đó. Để làm được điều này, bạn có thể sử dụng cú pháp from … import. Cú pháp này cho phép bạn nhập trực tiếp những đối tượng mong muốn từ một module vào chương trình hiện tại.

Ví dụ chúng ta có một module là my_module.py như sau:

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

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

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

Thay vì nhập tất cả các hàm trong my_module như import my_module chúng ta có thể nhập các hàm tong, hieu bằng cách sử dụng from my_module import và kết quả sẽ được thấy rõ khi chạy file vi_du.py dưới đây

from my_module import tong, hieu

print ("Tổng:", tong(10, 5))
print ("Hiệu:", hieu(10,5))

Khi chạy file vi_du.py chúng ta nhận được kết quả:

Lệnh from … import *

Trong Python, bạn cũng có thể nhập (import) tất cả các tên (hàm, biến,…) từ một module (module) vào không gian tên (namespace) hiện tại bằng cách sử dụng câu lệnh from ... import * như sau:

from <tên_module> import *

Câu lệnh này giúp chúng ta dễ dàng import tất cả các đối tượng từ một module, tuy nhiên, cần lưu ý sử dụng một cách hạn chế.

Lệnh import … as

Khi bạn sử dụng lệnh import để nạp một module (module), bạn có thể gán cho module đó một tên bí danh (alias) ngắn gọn hơn, dễ sử dụng hơn. Cú pháp như sau:

import ten_module as bi_danh

Khi đã có bí danh, bạn sẽ dùng tên bí danh thay cho tên thật của module khi gọi đến các hàm, biến hay các đối tượng khác bên trong. Việc này giúp code trở nên ngắn gọn và dễ đọc hơn, đặc biệt khi làm việc với các module có tên dài.

Để làm rõ hơn, hãy cùng xem xét một ví dụ. Trước hết, ta cần có một module trước, bạn có thể tạo file my_module.py có nội dung sau:

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

def calculate_average(a, b):
    return (a + b) / 2

def exponentiate(base, exponent):
    return base ** exponent

Giả sử trong chương trình chính, bạn muốn sử dụng các hàm sum_numbers, calculate_average, exponentiate, nhưng muốn đặt tên ngắn gọn cho module my_module bạn sẽ dùng import… as:

import my_module as calculator

result_sum = calculator.sum_numbers(10, 5)
result_average = calculator.calculate_average(10, 5)
result_power = calculator.exponentiate(2, 4)


print ("Tổng:", result_sum)
print ("Trung bình:", result_average)
print ("Lũy thừa:", result_power)

Xác định vị trí của Module

Khi bạn sử dụng lệnh import để đưa một module vào chương trình, trình thông dịch Python sẽ tìm kiếm module đó theo một trình tự ưu tiên nhất định. Thứ tự tìm kiếm này giúp Python biết chính xác cần tìm module ở đâu để có thể sử dụng các chức năng được định nghĩa bên trong.

Trình tự tìm kiếm module của Python như sau:

• Thư mục hiện tại: Đầu tiên, Python sẽ tìm kiếm module trong thư mục đang chứa script Python mà bạn đang chạy. Điều này có nghĩa, nếu file chứa module và file đang chạy ở cùng một chỗ, Python sẽ tìm thấy file này một cách dễ dàng.
• Biến môi trường PYTHONPATH: Nếu không tìm thấy module ở thư mục hiện tại, Python sẽ tiếp tục tìm trong các thư mục được liệt kê trong biến môi trường PYTHONPATH. PYTHONPATH là một biến môi trường mà bạn có thể thiết lập để chỉ định các đường dẫn thư mục chứa các module. Nếu bạn thường xuyên dùng những module tự tạo, bạn có thể thiết lập đường dẫn ở đây để Python luôn tìm ra chúng.
• Đường dẫn mặc định: Trong trường hợp vẫn không tìm thấy module, Python sẽ kiểm tra các đường dẫn mặc định của hệ thống. Thông thường, trên các hệ thống UNIX (như Linux hoặc macOS), đường dẫn mặc định này sẽ là /usr/local/lib/python/. Đường dẫn mặc định thường chứa các module được cài đặt sẵn trong hệ thống.

Mở rộng thêm về sys.path:

Đường dẫn tìm kiếm module (module) thực tế được lưu trữ trong biến sys.path thuộc module (module) sys. Biến này chứa một danh sách các đường dẫn mà Python sẽ tìm kiếm, bao gồm thư mục hiện tại, các thư mục trong PYTHONPATH và đường dẫn mặc định. Chúng ta hoàn toàn có thể xem các đường dẫn đó bằng đoạn code như sau:

import sys
print(sys.path)

Biến môi trường PYTHONPATH

Biến môi trường, nói một cách đơn giản, là những biến có thể được truy cập và sử dụng bởi hệ điều hành cũng như các chương trình khác. PYTHONPATH là một biến môi trường đặc biệt quan trọng trong Python. Khi bạn sử dụng lệnh import để nạp một module, Python sẽ tìm kiếm module đó trong các thư mục được chỉ định trong biến môi trường PYTHONPATH. Nếu không tìm thấy module ở bất kì thư mục nào, Python sẽ báo lỗi.

Dưới đây là một ví dụ về PYTHONPATH điển hình trên hệ thống Windows:

set PYTHONPATH = c:\python20\lib;

Còn đây là một ví dụ PYTHONPATH điển hình trên hệ thống UNIX (Linux, macOS):

set PYTHONPATH = /usr/local/lib/python

Namespaces và Scoping

Trong Python, biến là các tên (còn gọi là định danh) được liên kết đến các đối tượng trong bộ nhớ. Một không gian tên (namespace) là một dạng từ điển (dictionary), nơi các tên biến (khóa) được ánh xạ đến các đối tượng tương ứng (giá trị).

• Một câu lệnh trong Python có thể truy cập đến các biến nằm trong không gian tên cục bộ (local namespace) và không gian tên toàn cục (global namespace). Nếu một biến cục bộ và một biến toàn cục có cùng tên, biến cục bộ sẽ “che phủ” biến toàn cục, tức là khi truy cập đến tên biến đó, Python sẽ ưu tiên biến cục bộ.
• Mỗi hàm (function) đều có không gian tên cục bộ riêng. Các phương thức của lớp (class methods) cũng tuân theo quy tắc phạm vi hoạt động tương tự như các hàm thông thường.
• Python khá thông minh khi phán đoán xem một biến là cục bộ hay toàn cục. Python mặc định coi một biến được gán giá trị bên trong một hàm là biến cục bộ.
• Để gán giá trị cho một biến toàn cục bên trong hàm, trước hết bạn cần sử dụng từ khóa global.
• Câu lệnh global VarName thông báo cho Python biết rằng VarName là một biến toàn cục. Khi đó, Python sẽ không tìm kiếm biến này trong không gian tên cục bộ nữa.

Ví dụ

Để hiểu rõ hơn về cách Python quản lý không gian tên, hãy xem xét ví dụ sau:

Chúng ta có một biến tien (Money) được định nghĩa trong không gian tên toàn cục. Bên trong hàm tang_tien, chúng ta lại gán giá trị mới cho tien. Do đó, Python sẽ hiểu rằng tien bên trong hàm tang_tien là một biến cục bộ. Tuy nhiên, khi truy cập giá trị của biến tien cục bộ này trước khi gán cho nó, sẽ dẫn đến lỗi UnboundLocalError. Việc bỏ ghi chú (uncomment) dòng lệnh global tien sẽ giúp sửa lỗi này.

tien = 2000

def tang_tien():
   # Bỏ dấu comment dòng sau để sửa lỗi:
   # global tien
    tien = tien + 1
   

print(tien)
tang_tien()
print(tien)

Khi thực thi đoạn mã này (nếu chưa bỏ comment), Python sẽ báo lỗi, cụ thể:

Tuy nhiên nếu bạn bỏ ghi chú global tien thì kết quả trả ra sẽ khác:

Thuộc tính của Module

Trong Python, một module là một đối tượng thuộc lớp module, và do đó, mỗi module sẽ có những thuộc tính riêng. Để hiểu rõ hơn, chúng ta hãy cùng khám phá một vài thuộc tính phổ biến:

Các module trong Python cũng giống như những chiếc hộp đựng các công cụ, và mỗi chiếc hộp đó lại có các thông tin như sau:

• __file__: Thuộc tính này sẽ cho chúng ta biết vị trí vật lý của module đó, tức là module được lưu trữ ở đâu trong máy tính của bạn. Nó giống như địa chỉ nhà của module vậy.
• __package__: Khi module thuộc về một gói (package), thuộc tính này sẽ chỉ định tên của gói đó. Gói ở đây giống như một thư mục lớn chứa nhiều module có liên quan với nhau.
• __doc__: Khi người lập trình tạo ra một module, họ thường thêm vào một đoạn mô tả ngắn gọn ở đầu file, gọi là “docstring”. Thuộc tính __doc__ sẽ giúp chúng ta xem được nội dung của đoạn mô tả này, giống như là ghi chú hướng dẫn sử dụng cho module đó.
• __dict__: Đây là một thuộc tính đặc biệt, nó trả về toàn bộ không gian tên (namespace) của module. Nghĩa là, chúng ta có thể xem được danh sách các biến, hàm, class, và tất cả các “đồ vật” mà module đó đang giữ trong “túi” của nó.
• __name__: Thuộc tính này cho chúng ta biết tên của module đó. Khi chúng ta import một module, chúng ta thường sử dụng tên của module đó, đây chính là tên được trả về bởi thuộc tính __name__.

Ví dụ

Giả sử rằng đoạn code dưới đây được lưu vào file mymodule.py

"""Đây là tài liệu hướng dẫn của module mymodule"""
def tinh_tong(x, y):
    """Hàm tính tổng của hai số x và y."""
    return x + y

def tinh_trung_binh(x, y):
    """Hàm tính trung bình của hai số x và y."""
    return (x + y) / 2

def tinh_luy_thua(x, y):
  """Hàm tính lũy thừa của x lên y."""
  return x**y

Ta hãy kiểm tra các thuộc tính của module mymodule bằng cách nhập (import) nó vào một script khác:

import mymodule

print ("Thuộc tính __file__:", mymodule.__file__)
print ("Thuộc tính __doc__:", mymodule.__doc__)
print ("Thuộc tính __name__:", mymodule.__name__)

Đoạn mã trên khi chạy sẽ tạo ra kết quả:

Thuộc tính __name__

Thuộc tính __name__ của một module Python có ý nghĩa rất quan trọng. Hãy cùng tìm hiểu chi tiết hơn về nó.

Trong trình thông dịch Python (interactive shell), thuộc tính __name__ trả về giá trị '__main__'.

>>> __name__
'__main__'

Nếu bạn nhập (import) một module nào đó trong phiên làm việc với trình thông dịch, __name__ của module đó sẽ trả về tên của module.

>>> import math
>>> math.__name__
'math'

Từ bên trong một file script Python, thuộc tính __name__ cũng trả về giá trị ‘__main__‘.

#example.py
print ("Thuộc tính __name__ trong một script:", __name__)

Chạy đoạn code trên trong cửa sổ dòng lệnh (command terminal), bạn sẽ thấy kết quả:

Thuộc tính này cho phép một script Python vừa có thể chạy trực tiếp như một chương trình, vừa có thể được nhập vào như một module. Không giống như trong các ngôn ngữ lập trình C++, Java, C#, trong Python, không có khái niệm hàm main(). Một file script Python với phần mở rộng .py có thể chứa cả định nghĩa hàm (function definitions) và các câu lệnh thực thi (executable statements).

Bây giờ, hãy lưu một file có tên mymodule.py với nội dung code sau:

""" Đây là docstring của module mymodule """
def sum(x, y):
    """Hàm tính tổng hai số"""
    return x + y

print ("sum:", sum(10, 20))

Trong mymodule.py bạn có thể thấy hàm sum() được gọi ngay trong chính module đó, và kết quả in ra màn hình như sau:

Bây giờ, chúng ta hãy thử import hàm sum() từ module mymodule.py này vào một script (file Python) khác, giả sử tên là example.py.

# file example.py
import mymodule
print ("sum:", mymodule.sum(10, 20))

Khi chạy file example.py kết quả hiển thị sẽ là:

Ta thấy kết quả “sum: 30” xuất hiện hai lần. Một lần khi module mymodule được import, các lệnh có thể thực thi trong module đó cũng sẽ chạy. Lần thứ hai là từ lệnh gọi hàm trong file example.py

Tuy nhiên, chúng ta mong muốn rằng khi một module được import, thì chỉ có các hàm (hay các đối tượng) bên trong module được nhập vào, chứ các lệnh thực thi của module đó không nên chạy. Để làm được điều này, chúng ta cần kiểm tra giá trị của biến __name__. Nếu giá trị của __name__ là __main__, thì điều đó có nghĩa là module đang được chạy trực tiếp, chứ không phải đang được import. Hãy bao các lệnh thực thi như lệnh gọi hàm có điều kiện, và chỉ cho nó chạy khi biến __name__ có giá trị là __main__

Hãy thêm câu lệnh if vào file mymodule.py như sau:

"""The docstring of mymodule"""
def sum(x, y):
    return x + y

if __name__ == "__main__":
    print("sum:", sum(10, 20))

Bây giờ, nếu bạn chạy chương trình example.py (nếu bạn đã import module này ở file example.py thì kết quả mới đúng), bạn sẽ thấy dòng sum: 30 chỉ xuất hiện một lần.

Hàm dir ()

Trong Python, hàm dir() là một hàm dựng sẵn (built-in function) có khả năng trả về một danh sách các chuỗi đã được sắp xếp, chứa đựng tên của các thành phần được định nghĩa trong một module.

Nói một cách đơn giản hơn, hàm dir() cho bạn biết những cái tên gì (ví dụ: biến, hàm, module con) có sẵn bên trong một module. Danh sách này giúp bạn khám phá nội dung bên trong của một module một cách dễ dàng. Dưới đây là một ví dụ đơn giản để minh họa cách hàm dir() hoạt động:

# Nhập (import) module math
import math

noi_dung = dir(math)
print (noi_dung)

Khi chạy đoạn mã trên, kết quả hiển thị trên màn hình sẽ như sau:

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log', 'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']

Hàm reload() trong Python

Trong quá trình làm việc với Python, đặc biệt khi sử dụng trình thông dịch tương tác (interactive interpreter session), đôi khi bạn sẽ cần tải lại một module (hay còn gọi là module). Điều này xảy ra khi bạn muốn sử dụng phiên bản mới nhất của module sau khi đã chỉnh sửa.

Ví dụ bạn có một module kiểm thử (test.py) với hàm sau đây:

def SayHello(name):
    print ("Xin chào {}! Bạn khỏe không?".format(name))
    return

Bạn có thể nhập (import) module này và gọi hàm SayHello() từ giao diện dòng lệnh của Python như sau:

Tuy nhiên, ví dụ bạn muốn thay đổi hàm SayHello(), sẽ như sau:

def SayHello(name, course):
    print ("Xin chào {}! Bạn khỏe không?".format(name))
    print ("Chào mừng bạn đến với khóa học {} của Học viện ABC".format(course))
    return

Ngay cả khi bạn đã sửa đổi và lưu lại file test.py, hàm đã được tải vào bộ nhớ sẽ không tự động cập nhật. Để sử dụng phiên bản mới nhất của module này, bạn cần tải lại (reload) bằng cách sử dụng hàm reload() từ module imp.

Packages trong Python

Trong Python, một Package (gói) là một cấu trúc thư mục (directory) phân cấp, xác định một môi trường ứng dụng Python đơn nhất, bao gồm các module, các subpackage (gói con), các sub-subpackage (gói con của gói con), và cứ thế tiếp diễn.

Bạn có thể hình dung Package như một “tập hợp các ngăn” chứa đựng các module (các file .py chứa code). Package giúp tổ chức code một cách khoa học, dễ quản lý và tái sử dụng.

Ví dụ, bạn có một file Pots.py nằm trong thư mục Phone. File này chứa đoạn mã sau:

def Pots():
    print ("Tôi là Pots Phone")

Tương tự, chúng ta có thêm hai file khác, mỗi file chứa một hàm với cùng tên như trên, nhưng có chức năng khác:

• File Isdn.py nằm trong thư mục Phone, có chứa hàm Isdn()
• File G3.py nằm trong thư mục Phone, có chứa hàm G3()

Bây giờ, hãy tạo thêm một file nữa có tên là __init__.py trong thư mục Phone:

• File __init__.py nằm trong thư mục Phone

Để có thể sử dụng tất cả các hàm đã tạo bên trong một package (ví dụ như Phone package) khi đã import, bạn cần khai báo rõ ràng các import statements trong file __init__.py như sau:

from Pots import Pots
from Isdn import Isdn
from G3 import G3

Sau khi thêm những dòng này vào file __init__.py, bạn sẽ có thể sử dụng tất cả các lớp (classes) bên trong các module này khi import Phone package.

Ví dụ, bạn đã tạo một package có tên Phone và có các module như sau: Pots.py, Isdn.py, và G3.py. Sau khi cấu hình file __init__.py như trên, bạn có thể sử dụng package Phone như sau:

# Import Phone Package.
import Phone

# Gọi đến các class trong package Phone
Phone.Pots()
Phone.Isdn()
Phone.G3()

Khi thực thi đoạn mã trên, kết quả sẽ như sau:

Lời kết

Vậy là chúng ta đã cùng nhau tìm hiểu chi tiết về Modules trong Python, từ định nghĩa cơ bản đến cách sử dụng và những lợi ích mà module mang lại. Hy vọng những kiến thức này sẽ giúp bạn có cái nhìn rõ ràng hơn về Module, từ đó ứng dụng hiệu quả vào quá trình lập trình Python của mình. Đừng quên thực hành thường xuyên để nắm vững các kiến thức nằm trong bài chia sẻ.