Hướng dẫn what is a module in python example? - một mô-đun trong ví dụ về python là gì?


Mô -đun là gì?

Coi một mô -đun giống như thư viện mã.

Một tệp chứa một tập hợp các chức năng bạn muốn đưa vào ứng dụng của mình.


Tạo một mô -đun

Để tạo mô -đun, chỉ cần lưu mã bạn muốn trong một tệp với phần mở rộng tệp

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
5:

Thí dụ

Lưu mã này trong một tệp có tên

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6

Def Greeting (Tên): & NBSP; in ("Xin chào" + tên)
  print("Hello, " + name)

Sử dụng một mô -đun

Bây giờ chúng ta có thể sử dụng mô -đun mà chúng ta vừa tạo, bằng cách sử dụng câu lệnh

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
7:

Thí dụ

Lưu mã này trong một tệp có tên

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6

Def Greeting (Tên): & NBSP; in ("Xin chào" + tên)

Sử dụng một mô -đun

Bây giờ chúng ta có thể sử dụng mô -đun mà chúng ta vừa tạo, bằng cách sử dụng câu lệnh

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
7:

Nhập mô -đun có tên MyModule và gọi hàm lời chào: When using a function from a module, use the syntax: module_name.function_name.


Nhập myModule

mymodule.greeting ("Jonathan")

Thí dụ

Lưu mã này trong một tệp có tên

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6

Def Greeting (Tên): & NBSP; in ("Xin chào" + tên)
  "name": "John",
  "age": 36,
  "country": "Norway"
}

Thí dụ

Lưu mã này trong một tệp có tên

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6

Def Greeting (Tên): & NBSP; in ("Xin chào" + tên)

Sử dụng một mô -đun
print(a)

Bây giờ chúng ta có thể sử dụng mô -đun mà chúng ta vừa tạo, bằng cách sử dụng câu lệnh

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
7:



Nhập mô -đun có tên MyModule và gọi hàm lời chào:

Nhập myModule

mymodule.greeting ("Jonathan")

Chạy ví dụ »

Thí dụ

Lưu mã này trong một tệp có tên

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6

Def Greeting (Tên): & NBSP; in ("Xin chào" + tên)

Sử dụng một mô -đun
print(a)

Bây giờ chúng ta có thể sử dụng mô -đun mà chúng ta vừa tạo, bằng cách sử dụng câu lệnh

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
7:


Nhập mô -đun có tên MyModule và gọi hàm lời chào:

Nhập myModule

Thí dụ

Lưu mã này trong một tệp có tên

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6

Def Greeting (Tên): & NBSP; in ("Xin chào" + tên)

Sử dụng một mô -đun
print(x)

Bây giờ chúng ta có thể sử dụng mô -đun mà chúng ta vừa tạo, bằng cách sử dụng câu lệnh

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
7:


Nhập mô -đun có tên MyModule và gọi hàm lời chào:

Nhập myModule

Thí dụ

Lưu mã này trong một tệp có tên

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6

Def Greeting (Tên): & NBSP; in ("Xin chào" + tên)

Sử dụng một mô -đun
print(x)

Bây giờ chúng ta có thể sử dụng mô -đun mà chúng ta vừa tạo, bằng cách sử dụng câu lệnh

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
7:

Nhập mô -đun có tên MyModule và gọi hàm lời chào: The dir() function can be used on all modules, also the ones you create yourself.


Nhập myModule

mymodule.greeting ("Jonathan")

Thí dụ

Chạy ví dụ »

Def Greeting (Tên): & NBSP; in ("Xin chào" + tên)
  print("Hello, " + name)

Sử dụng một mô -đun
  "name": "John",
  "age": 36,
  "country": "Norway"
}

Thí dụ

Bây giờ chúng ta có thể sử dụng mô -đun mà chúng ta vừa tạo, bằng cách sử dụng câu lệnh

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
7:

Nhập mô -đun có tên MyModule và gọi hàm lời chào:

Nhập myModule

Bây giờ chúng ta có thể sử dụng mô -đun mà chúng ta vừa tạo, bằng cách sử dụng câu lệnh

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
7:

Nhập mô -đun có tên MyModule và gọi hàm lời chào: When importing using the

>>> from fibo import fib, fib2
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
5 keyword, do not use the module name when referring to elements in the module. Example:
>>> from fibo import fib, fib2
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
8, not
>>> from fibo import fib, fib2
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
9


Nhập myModule

Exercise:

mymodule.greeting ("Jonathan")

Chạy ví dụ »



Nếu bạn thoát khỏi trình thông dịch Python và nhập lại, các định nghĩa bạn đã thực hiện (chức năng và biến) sẽ bị mất. Do đó, nếu bạn muốn viết một chương trình dài hơn một chút, bạn nên sử dụng trình soạn thảo văn bản để chuẩn bị đầu vào cho trình thông dịch và chạy nó với tệp đó làm đầu vào thay thế. Điều này được gọi là tạo một kịch bản. Khi chương trình của bạn lâu hơn, bạn có thể muốn chia nó thành một số tệp để bảo trì dễ dàng hơn. Bạn cũng có thể muốn sử dụng một chức năng tiện dụng mà bạn đã viết trong một số chương trình mà không sao chép định nghĩa của nó vào từng chương trình.

Để hỗ trợ điều này, Python có một cách để đặt các định nghĩa vào một tệp và sử dụng chúng trong một tập lệnh hoặc trong một trường hợp tương tác của trình thông dịch. Một tập tin như vậy được gọi là một mô -đun; Các định nghĩa từ một mô -đun có thể được nhập vào các mô -đun khác hoặc vào mô -đun chính (bộ sưu tập các biến mà bạn có quyền truy cập trong tập lệnh được thực thi ở cấp cao nhất và ở chế độ máy tính).

Một mô -đun là một tệp chứa các định nghĩa và câu lệnh Python. Tên tệp là tên mô -đun với hậu tố

>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
0 được nối thêm. Trong một mô -đun, tên mô -đun (dưới dạng chuỗi) có sẵn dưới dạng giá trị của biến toàn cầu
>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
1. Chẳng hạn, sử dụng trình soạn thảo văn bản yêu thích của bạn để tạo một tệp có tên
>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
2 trong thư mục hiện tại với các nội dung sau:

# Fibonacci numbers module

def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while a < n:
        print(a, end=' ')
        a, b = b, a+b
    print()

def fib2(n):   # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while a < n:
        result.append(a)
        a, b = b, a+b
    return result

Bây giờ nhập trình thông dịch Python và nhập mô -đun này bằng lệnh sau:

Điều này không thêm tên của các hàm được xác định trong

>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3 trực tiếp vào không gian tên hiện tại (xem phạm vi Python và không gian tên để biết thêm chi tiết); Nó chỉ thêm tên mô -đun
>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3 ở đó. Sử dụng tên mô -đun, bạn có thể truy cập các chức năng:namespace (see Python Scopes and Namespaces for more details); it only adds the module name
>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3 there. Using the module name you can access the functions:

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'

Nếu bạn có ý định sử dụng một chức năng thường xuyên, bạn có thể gán nó cho một tên cục bộ:

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

6.1. Thêm về các mô -đunMore on Modules¶

Một mô -đun có thể chứa các câu lệnh thực thi cũng như các định nghĩa chức năng. Các câu lệnh này được dự định để khởi tạo mô -đun. Chúng chỉ được thực thi ngay lần đầu tiên tên mô -đun gặp trong một câu lệnh nhập. 1 (chúng cũng được chạy nếu tệp được thực thi dưới dạng tập lệnh.)

Mỗi mô -đun có không gian tên riêng, được sử dụng làm không gian tên toàn cầu bởi tất cả các hàm được xác định trong mô -đun. Do đó, tác giả của một mô -đun có thể sử dụng các biến toàn cầu trong mô -đun mà không phải lo lắng về các cuộc đụng độ tình cờ với các biến toàn cầu của người dùng. Mặt khác, nếu bạn biết những gì bạn đang làm, bạn có thể chạm vào các biến toàn cầu của mô -đun với cùng một ký hiệu được sử dụng để chỉ các chức năng của nó,

>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
5.

Các mô -đun có thể nhập các mô -đun khác. Đó là thông lệ nhưng không bắt buộc phải đặt tất cả các câu lệnh

>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6 khi bắt đầu một mô -đun (hoặc tập lệnh, cho vấn đề đó). Các tên mô -đun đã nhập, nếu được đặt ở cấp cao nhất của một mô -đun (bên ngoài bất kỳ chức năng hoặc lớp nào), sẽ được thêm vào không gian tên toàn cầu của mô -đun.

Có một biến thể của câu lệnh

>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6 nhập tên từ một mô -đun trực tiếp vào không gian tên mô -đun nhập mô -đun. Ví dụ:

>>> from fibo import fib, fib2
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Điều này không giới thiệu tên mô -đun mà từ đó nhập khẩu được thực hiện trong không gian tên cục bộ (vì vậy trong ví dụ,

>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3 không được xác định).

Thậm chí còn có một biến thể để nhập tất cả các tên mà một mô -đun xác định:

>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Điều này nhập tất cả các tên ngoại trừ các tên bắt đầu bằng dấu gạch dưới (

>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
9). Trong hầu hết các trường hợp, các lập trình viên Python không sử dụng cơ sở này vì nó đưa một bộ tên không xác định vào trình thông dịch, có thể che giấu một số điều bạn đã xác định.

Lưu ý rằng nói chung, thực tiễn nhập

>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
0 từ một mô -đun hoặc gói được cau mày, vì nó thường gây ra mã có thể đọc được kém. Tuy nhiên, việc sử dụng nó là ổn để lưu gõ trong các phiên tương tác.

Nếu tên mô -đun được theo sau bởi

>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
1, thì tên sau
>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
1 bị ràng buộc trực tiếp với mô -đun đã nhập.

>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Điều này là nhập hiệu quả mô -đun theo cùng một cách mà

>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3 sẽ làm, với sự khác biệt duy nhất của nó có sẵn là
>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
4.

Nó cũng có thể được sử dụng khi sử dụng

>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
5 với các hiệu ứng tương tự:

>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Ghi chú

Vì lý do hiệu quả, mỗi mô -đun chỉ được nhập một lần cho mỗi phiên phiên dịch. Do đó, nếu bạn thay đổi các mô -đun của mình, bạn phải khởi động lại trình thông dịch - hoặc, nếu nó chỉ là một mô -đun bạn muốn kiểm tra tương tác, hãy sử dụng

>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6, ví dụ:
>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
7.

6.1.1. Thực hiện các mô -đun dưới dạng tập lệnhExecuting modules as scripts¶

Khi bạn chạy một mô -đun Python với

python fibo.py <arguments>

Mã trong mô -đun sẽ được thực thi, giống như khi bạn nhập nó, nhưng với

>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
1 được đặt thành
>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
9. Điều đó có nghĩa là bằng cách thêm mã này vào cuối mô -đun của bạn:

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

Bạn có thể làm cho tệp có thể sử dụng được dưới dạng tập lệnh cũng như một mô -đun có thể nhập, bởi vì mã phân tích dòng lệnh chỉ chạy nếu mô -đun được thực thi dưới dạng tệp chính của Hồi giáo:

$ python fibo.py 50
0 1 1 2 3 5 8 13 21 34

Nếu mô -đun được nhập, mã không được chạy:

Điều này thường được sử dụng để cung cấp giao diện người dùng thuận tiện cho một mô -đun hoặc cho mục đích thử nghiệm (chạy mô -đun dưới dạng tập lệnh thực thi bộ thử nghiệm).

6.1.2. Đường dẫn tìm kiếm mô -đunThe Module Search Path¶

Khi một mô-đun có tên

>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
0 được nhập, trình thông dịch trước tiên tìm kiếm một mô-đun tích hợp với tên đó. Các tên mô -đun này được liệt kê trong
>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
1. Nếu không tìm thấy, sau đó nó sẽ tìm kiếm một tệp có tên
>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
2 trong danh sách các thư mục được đưa ra bởi biến
>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3.
>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3 được khởi tạo từ các vị trí này:

  • Thư mục chứa tập lệnh đầu vào (hoặc thư mục hiện tại khi không có tệp được chỉ định).

  • >>> from fibo import fib as fibonacci
    >>> fibonacci(500)
    0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
    
    5 (danh sách các tên thư mục, có cùng cú pháp với biến shell
    >>> from fibo import fib as fibonacci
    >>> fibonacci(500)
    0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
    
    6).
    >>> from fibo import fib as fibonacci
    >>> fibonacci(500)
    0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
    
    6).

  • Mặc định phụ thuộc vào cài đặt (theo quy ước bao gồm thư mục

    >>> from fibo import fib as fibonacci
    >>> fibonacci(500)
    0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
    
    7, được xử lý bởi mô-đun
    >>> from fibo import fib as fibonacci
    >>> fibonacci(500)
    0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
    
    8).

Thêm chi tiết là khởi tạo của đường dẫn tìm kiếm mô -đun sys.path.The initialization of the sys.path module search path.

Ghi chú

Vì lý do hiệu quả, mỗi mô -đun chỉ được nhập một lần cho mỗi phiên phiên dịch. Do đó, nếu bạn thay đổi các mô -đun của mình, bạn phải khởi động lại trình thông dịch - hoặc, nếu nó chỉ là một mô -đun bạn muốn kiểm tra tương tác, hãy sử dụng

>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6, ví dụ:
>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
7.not added to the module search path.

Sau khi khởi tạo, các chương trình Python có thể sửa đổi

>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3. Thư mục chứa tập lệnh được chạy được đặt ở đầu đường tìm kiếm, trước đường dẫn thư viện tiêu chuẩn. Điều này có nghĩa là các tập lệnh trong thư mục đó sẽ được tải thay vì các mô -đun cùng tên trong thư mục thư viện. Đây là một lỗi trừ khi dự định thay thế. Xem phần Mô -đun tiêu chuẩn để biết thêm thông tin.Standard Modules for more information.

6.1.3. Các tập tin của Python đã biên dịch“Compiled” Python files¶

Để tăng tốc các mô -đun tải, Python lưu trữ phiên bản biên dịch của mỗi mô -đun trong thư mục

python fibo.py <arguments>
0 dưới tên
python fibo.py <arguments>
1, trong đó phiên bản mã hóa định dạng của tệp được biên dịch; Nó thường chứa số phiên bản Python. Ví dụ: trong CPYThon Release 3.3, phiên bản biên dịch của spam.py sẽ được lưu trữ là
python fibo.py <arguments>
2. Quy ước đặt tên này cho phép các mô -đun được biên dịch từ các bản phát hành khác nhau và các phiên bản khác nhau của Python để cùng tồn tại.

Python kiểm tra ngày sửa đổi của nguồn so với phiên bản được biên dịch để xem liệu nó có lỗi thời hay không và cần phải được biên dịch lại. Đây là một quá trình hoàn toàn tự động. Ngoài ra, các mô-đun được biên dịch không phụ thuộc vào nền tảng, vì vậy cùng một thư viện có thể được chia sẻ giữa các hệ thống với các kiến ​​trúc khác nhau.

Python không kiểm tra bộ đệm trong hai trường hợp. Đầu tiên, nó luôn luôn biên dịch lại và không lưu trữ kết quả cho mô -đun được tải trực tiếp từ dòng lệnh. Thứ hai, nó không kiểm tra bộ đệm nếu không có mô -đun nguồn. Để hỗ trợ phân phối không nguồn (chỉ được biên dịch), mô-đun được biên dịch phải nằm trong thư mục nguồn và không được có mô-đun nguồn.

Một số mẹo cho các chuyên gia:

  • Bạn có thể sử dụng các công tắc

    python fibo.py <arguments>
    
    3 hoặc
    python fibo.py <arguments>
    
    4 trên lệnh Python để giảm kích thước của một mô -đun được biên dịch. Chuyển đổi
    python fibo.py <arguments>
    
    3 Xóa các câu lệnh ARPERT, công tắc
    python fibo.py <arguments>
    
    4 sẽ loại bỏ cả hai câu lệnh ARPER và __DOC__. Vì một số chương trình có thể dựa vào việc có những thứ này có sẵn, bạn chỉ nên sử dụng tùy chọn này nếu bạn biết bạn đang làm gì. Các mô -đun tối ưu hóa có thể có thẻ
    python fibo.py <arguments>
    
    7 và thường nhỏ hơn. Phát hành trong tương lai có thể thay đổi tác động của tối ưu hóa.

  • Một chương trình không chạy nhanh hơn khi nó được đọc từ tệp

    python fibo.py <arguments>
    
    8 so với khi nó được đọc từ tệp
    >>> from fibo import *
    >>> fib(500)
    0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
    
    0; Điều duy nhất mà các tệp nhanh hơn về các tệp
    python fibo.py <arguments>
    
    8 là tốc độ mà chúng được tải.

  • Mô -đun

    if __name__ == "__main__":
        import sys
        fib(int(sys.argv[1]))
    
    1 có thể tạo các tệp .pyc cho tất cả các mô -đun trong một thư mục.

  • Có nhiều chi tiết hơn về quy trình này, bao gồm biểu đồ dòng chảy của các quyết định, trong PEP 3147.PEP 3147.

6.2. Mô -đun tiêu chuẩnStandard Modules¶

Python đi kèm với một thư viện các mô -đun tiêu chuẩn, được mô tả trong một tài liệu riêng biệt, tài liệu tham khảo thư viện Python (Tài liệu tham khảo thư viện của Hồi giáo sau đây). Một số mô -đun được xây dựng vào thông dịch viên; Chúng cung cấp quyền truy cập vào các hoạt động không phải là một phần cốt lõi của ngôn ngữ nhưng vẫn được tích hợp, cho hiệu quả hoặc cung cấp quyền truy cập vào các nguyên thủy hệ điều hành như các cuộc gọi hệ thống. Tập hợp các mô -đun như vậy là một tùy chọn cấu hình cũng phụ thuộc vào nền tảng cơ bản. Ví dụ: mô -đun

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))
2 chỉ được cung cấp trên các hệ thống Windows. Một mô -đun cụ thể xứng đáng được chú ý:
if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))
3, được xây dựng thành mọi phiên dịch viên Python. Các biến
if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))
4 và
if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))
5 Xác định các chuỗi được sử dụng làm lời nhắc chính và phụ:

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
0

Hai biến này chỉ được xác định nếu trình thông dịch ở chế độ tương tác.

Biến

>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3 là danh sách các chuỗi xác định đường dẫn tìm kiếm của trình thông dịch cho các mô -đun. Nó được khởi tạo thành một đường dẫn mặc định được lấy từ biến môi trường
>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
5 hoặc từ mặc định tích hợp nếu
>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
5 không được đặt. Bạn có thể sửa đổi nó bằng cách sử dụng các hoạt động danh sách tiêu chuẩn:
>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
5, or from a built-in default if
>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
5 is not set. You can modify it using standard list operations:

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
1

6.3. Hàm if __name__ == "__main__": import sys fib(int(sys.argv[1])) 9The if __name__ == "__main__": import sys fib(int(sys.argv[1])) 9 Function¶

Hàm tích hợp

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))
9 được sử dụng để tìm ra tên nào một mô-đun xác định. Nó trả về một danh sách các chuỗi được sắp xếp:

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
2

Không có đối số,

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))
9 liệt kê các tên bạn đã xác định hiện tại:

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
3

Lưu ý rằng nó liệt kê tất cả các loại tên: biến, mô -đun, chức năng, v.v.

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))
9 không liệt kê tên của các hàm và biến tích hợp. Nếu bạn muốn một danh sách những người đó, chúng được xác định trong mô -đun tiêu chuẩn
$ python fibo.py 50
0 1 1 2 3 5 8 13 21 34
3:

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
4

6.4. GóiPackages¶

Các gói là một cách cấu trúc không gian tên mô -đun Python bằng cách sử dụng tên mô -đun chấm chấm chấm. Ví dụ: tên mô -đun

$ python fibo.py 50
0 1 1 2 3 5 8 13 21 34
4 chỉ định một mô hình con có tên
$ python fibo.py 50
0 1 1 2 3 5 8 13 21 34
5 trong một gói có tên
$ python fibo.py 50
0 1 1 2 3 5 8 13 21 34
6. Giống như việc sử dụng các mô-đun giúp các tác giả của các mô-đun khác nhau phải lo lắng về các tên biến toàn cầu của nhau, việc sử dụng tên mô-đun chấm có lưu các tác giả của các gói đa mô-đun như Numpy hoặc Gối không phải lo lắng về tên mô-đun của nhau .

Giả sử bạn muốn thiết kế một bộ sưu tập các mô -đun (một gói trực tuyến) để xử lý thống nhất các tệp âm thanh và dữ liệu âm thanh. Có nhiều định dạng tệp âm thanh khác nhau (thường được nhận ra bởi phần mở rộng của chúng, ví dụ:

$ python fibo.py 50
0 1 1 2 3 5 8 13 21 34
7,
$ python fibo.py 50
0 1 1 2 3 5 8 13 21 34
8,
$ python fibo.py 50
0 1 1 2 3 5 8 13 21 34
9), do đó bạn có thể cần tạo và duy trì một bộ sưu tập các mô -đun phát triển để chuyển đổi giữa các định dạng tệp khác nhau. Ngoài ra còn có nhiều hoạt động khác nhau mà bạn có thể muốn thực hiện trên dữ liệu âm thanh (chẳng hạn như trộn, thêm Echo, áp dụng chức năng cân bằng, tạo hiệu ứng âm thanh nhân tạo), do đó, bạn sẽ viết một luồng mô-đun không bao giờ kết thúc để thực hiện những hoạt động này. Ở đây, một cấu trúc có thể cho gói của bạn (được thể hiện dưới dạng hệ thống tập tin phân cấp):

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
5

Khi nhập gói, Python tìm kiếm thông qua các thư mục trên

>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3 để tìm kiếm thư mục con.

Các tệp

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
01 được yêu cầu để làm cho các thư mục xử lý Python chứa tệp dưới dạng các gói. Điều này ngăn chặn các thư mục với một tên chung, chẳng hạn như
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
02, vô tình ẩn các mô -đun hợp lệ xảy ra sau đó trên đường dẫn tìm kiếm mô -đun. Trong trường hợp đơn giản nhất,
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
01 chỉ có thể là một tệp trống, nhưng nó cũng có thể thực thi mã khởi tạo cho gói hoặc đặt biến
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
04, được mô tả sau.

Người dùng của gói có thể nhập các mô -đun riêng lẻ từ gói, ví dụ:

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
6

Điều này tải mô hình con

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
05. Nó phải được tham chiếu với tên đầy đủ của nó.

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
7

Một cách khác để nhập mô hình con là:

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
8

Điều này cũng tải mô hình con

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
06 và cung cấp nó mà không có tiền tố gói của nó, do đó nó có thể được sử dụng như sau:

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
9

Tuy nhiên, một biến thể khác là nhập chức năng mong muốn hoặc biến trực tiếp:

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
0

Một lần nữa, điều này tải mô hình con

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
06, nhưng điều này làm cho chức năng của nó
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
08 có sẵn trực tiếp:

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
1

Lưu ý rằng khi sử dụng

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
09, mục này có thể là một mô hình con (hoặc gói con) của gói hoặc một số tên khác được xác định trong gói, như hàm, lớp hoặc biến. Tuyên bố
>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6 đầu tiên kiểm tra xem mục được xác định trong gói; Nếu không, nó giả định nó là một mô -đun và cố gắng tải nó. Nếu nó không tìm thấy nó, một ngoại lệ
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
11 sẽ được nâng lên.

Ngược lại, khi sử dụng cú pháp như

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
12, mỗi mục ngoại trừ phần cuối cùng phải là một gói; Mục cuối cùng có thể là một mô -đun hoặc gói nhưng có thể là một lớp hoặc chức năng hoặc biến được xác định trong mục trước.

6.4.1. Nhập khẩu * từ GóiImporting * From a Package¶

Bây giờ điều gì xảy ra khi người dùng viết

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
13? Lý tưởng nhất, người ta sẽ hy vọng rằng điều này bằng cách nào đó đi ra khỏi hệ thống tập tin, tìm thấy những mô hình con nào có trong gói và nhập tất cả chúng. Điều này có thể mất nhiều thời gian và nhập các mô-đun phụ có thể có các tác dụng phụ không mong muốn chỉ nên xảy ra khi mô hình phụ được nhập rõ ràng.

Giải pháp duy nhất là tác giả gói để cung cấp một chỉ mục rõ ràng của gói. Tuyên bố

>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6 sử dụng quy ước sau: Nếu mã gói ____ ____101 định nghĩa một danh sách có tên
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
04, thì nó được coi là danh sách các tên mô -đun nên được nhập khi gặp phải
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
17. Tùy thuộc vào gói tác giả để giữ cho danh sách này được cập nhật khi một phiên bản mới của gói được phát hành. Các tác giả gói cũng có thể quyết định không hỗ trợ nó, nếu họ không thấy việc sử dụng để nhập * từ gói của họ. Ví dụ: tệp
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
18 có thể chứa mã sau:

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
2

Điều này có nghĩa là

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
13 sẽ nhập ba mô hình con có tên của gói
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
20.

Nếu

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
04 không được xác định, câu lệnh
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
13 không nhập tất cả các mô hình con từ gói
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
20 vào không gian tên hiện tại; Nó chỉ đảm bảo rằng gói
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
20 đã được nhập (có thể đang chạy bất kỳ mã khởi tạo nào trong
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
01) và sau đó nhập bất kỳ tên nào được xác định trong gói. Điều này bao gồm bất kỳ tên nào được xác định (và các mô hình con được tải rõ ràng) bởi
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
01. Nó cũng bao gồm bất kỳ mô hình con nào của gói được tải rõ ràng bởi các câu lệnh
>>> from fibo import *
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6 trước đó. Xem xét mã này:

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3

Trong ví dụ này, các mô -đun

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
06 và
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
29 được nhập trong không gian tên hiện tại vì chúng được xác định trong gói
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
20 khi câu lệnh
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
31 được thực thi. (Điều này cũng hoạt động khi
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
04 được xác định.)

Mặc dù một số mô -đun nhất định được thiết kế để chỉ xuất các tên theo các mẫu nhất định khi bạn sử dụng

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
33, nhưng nó vẫn được coi là thực tiễn xấu trong mã sản xuất.

Hãy nhớ rằng, không có gì sai khi sử dụng

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
34! Trên thực tế, đây là ký hiệu được đề xuất trừ khi mô -đun nhập cần sử dụng các mô hình con có cùng tên từ các gói khác nhau.

6.4.2. Tài liệu tham khảo nội bộIntra-package References¶

Khi các gói được cấu trúc thành các gói con (như với gói

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
35 trong ví dụ), bạn có thể sử dụng nhập khẩu tuyệt đối để chỉ các mô hình con của các gói anh chị em. Ví dụ: nếu mô -đun
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
36 cần sử dụng mô -đun
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
06 trong gói
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
20, nó có thể sử dụng
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
39.

Bạn cũng có thể viết nhập khẩu tương đối, với hình thức

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
40 của báo cáo nhập khẩu. Các nhập khẩu này sử dụng các dấu chấm hàng đầu để chỉ ra các gói hiện tại và cha mẹ liên quan đến nhập khẩu tương đối. Ví dụ, từ mô -đun
>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
29, bạn có thể sử dụng:

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
4

Lưu ý rằng nhập khẩu tương đối được dựa trên tên của mô -đun hiện tại. Vì tên của mô -đun chính luôn là

>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
9, các mô -đun dự định sử dụng làm mô -đun chính của ứng dụng Python phải luôn sử dụng nhập khẩu tuyệt đối.

6.4.3. Các gói trong nhiều thư mụcPackages in Multiple Directories¶

Các gói hỗ trợ thêm một thuộc tính đặc biệt,

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
43. Điều này được khởi tạo để trở thành một danh sách chứa tên của thư mục giữ gói ____ ____101 trước khi mã trong tệp đó được thực thi. Biến này có thể được sửa đổi; Làm như vậy ảnh hưởng đến các tìm kiếm trong tương lai cho các mô -đun và thanh toán con có trong gói.

Mặc dù tính năng này không cần thiết, nhưng nó có thể được sử dụng để mở rộng tập hợp các mô -đun được tìm thấy trong một gói.

Chú thích

1

Trong thực tế, các định nghĩa chức năng cũng là ‘các câu lệnh được thực hiện; Việc thực hiện định nghĩa hàm cấp mô-đun thêm tên hàm vào không gian tên toàn cầu mô-đun.

Các mô -đun trong Python là gì?

Mô -đun Python là một tệp chứa các định nghĩa và câu lệnh Python.Một mô -đun có thể xác định các chức năng, lớp và biến.Một mô -đun cũng có thể bao gồm mã Runnable.Nhóm mã liên quan thành một mô -đun giúp mã dễ hiểu và sử dụng hơn.Nó cũng làm cho mã được tổ chức một cách hợp lý.a file containing Python definitions and statements. A module can define functions, classes, and variables. A module can also include runnable code. Grouping related code into a module makes the code easier to understand and use. It also makes the code logically organized.

Mô -đun chính trong Python là gì?

Các mô -đun Python giải thích các tệp Python được gọi là các mô -đun và chúng được xác định bởi.Tiện ích mở rộng tệp PY.Một mô -đun có thể xác định các chức năng, lớp và biến.Vì vậy, khi trình thông dịch chạy một mô -đun, biến __name__ sẽ được đặt là __main__ nếu mô -đun đang được chạy là chương trình chính.when the interpreter runs a module, the __name__ variable will be set as __main__ if the module that is being run is the main program.