Python đọc bytearray

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 đã tạo (hàm 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, tốt hơn hế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 dài hơn, bạn có thể muốn chia nó thành nhiều 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 cần 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 để đưa 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 phiên bản tương tác của trình thông dịch. Một tệp như vậy được gọi là một mô-đun;

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 có thêm hậu 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'
7. Trong một mô-đun, tên của mô-đun (dưới dạng chuỗi) có sẵn dưới dạng giá trị của biến toàn cụ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'
8. 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
>>> 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 trong thư mục hiện tại với 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ờ hãy nhập trình thông dịch Python và nhập mô-đun này bằng lệnh sau

>>> import fibo

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

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
0 vào không gian tên hiện tại (xem Python Scopes and Namespaces for more details); it only adds the module name
>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
0 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 địa phương

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

6. 1. Thông tin thêm về Mô-đun¶

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 hàm. Các câu lệnh này nhằm mục đích khởi tạo mô-đun. Chúng chỉ được thực thi khi tên mô-đun xuất hiện lần đầu tiên trong 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ủa nó, được sử dụng làm không gian tên chung bởi tất cả các chức năng đượ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ục trong mô-đun mà không phải lo lắng về xung đột tình cờ với các biến toàn cục của người dùng. Mặt khác, nếu bạn biết mình đang làm gì, bạn có thể chạm vào các biến toàn cục 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ó,

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

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

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3 ở đầu mô-đun (hoặc tập lệnh, đối với vấn đề đó). Tên mô-đun đã nhập, nếu được đặt ở cấp cao nhất của 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 chung của mô-đun

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

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3 nhập tên từ mô-đun trực tiếp vào không gian tên của mô-đun nhập. 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'
2

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

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
0 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ô-đun xác đị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'
4

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

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6). 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 tiện ích 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ể ẩn một số thứ bạn đã xác định

Lưu ý rằng nói chung, việc nhập

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
7 từ một mô-đun hoặc gói không được chấp nhận, vì nó thường gây ra mã khó đọc. Tuy nhiên dùng để tiết kiệm gõ trong các buổi tương tác cũng được

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

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
8, thì tên theo sau
>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
8 sẽ được liên kết trực tiếp với mô-đun đã nhậ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'
9

Điều này đang nhập mô-đun một cách hiệu quả giống như cách mà

>>> 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 sẽ thực hiện, với sự khác biệt duy nhất là nó có sẵn dưới 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'
21

Nó cũng có thể được sử dụ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'
22 với tác dụng tương 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'
3

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 đó chỉ là một mô-đun mà bạn muốn kiểm tra tương tác, hãy 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'
23, e. g.
>>> 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'
24

6. 1. 1. Thực thi các mô-đun dưới dạng tập lệnh¶

Khi bạn chạy một mô-đun Python vớ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'
6

mã trong mô-đun sẽ được thực thi, giống như khi bạn nhập mã, nhưng vớ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'
8 được đặt thà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'
26. Đ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

>>> 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

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ô-đun có thể nhập, bởi vì mã phân tích cú pháp dòng lệnh chỉ chạy nếu mô-đun được thực thi dưới dạng tệp "chính"

>>> import fibo
0

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

>>> import fibo
1

Đ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ô-đ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ô-đun¶

Khi một mô-đun 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'
27 được nhập, trước tiên, trình thông dịch sẽ tìm kiếm một mô-đun tích hợp có tên đó. Các tên mô-đun này được liệt kê 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'
28. Nếu không tìm thấy, nó sẽ tìm kiếm một tệp 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'
29 trong danh sách các thư mục được cung cấp bởi 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'
40.
>>> 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 khởi tạo từ những 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 nào được chỉ đị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'
    
    42 (danh sách tên thư mục, có cùng cú pháp với biến hệ 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'
    
    43)

  • Mặc định phụ thuộc vào cài đặt (theo quy ước bao gồm một thư mụ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'
    
    44, được xử lý bởi 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'
    
    45)

Thông tin chi tiết có tại Việc khởi tạo hệ thống. đường dẫn tìm kiếm mô-đun đường dẫn .

Ghi chú

Trên các hệ thống tệp hỗ trợ liên kết tượng trưng, ​​thư mục chứa tập lệnh đầu vào được tính sau khi liên kết tượng trưng được theo dõi. Nói cách khác, thư mục chứa liên kết tượng trưng không được thêm vào đường dẫn tìm kiếm mô-đun

Sau khi khởi tạo, các chương trình Python có thể sửa đổ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'
40. Thư mục chứa tập lệnh đang chạy được đặt ở đầu đường dẫn tìm kiếm, phía trước đường dẫn thư viện 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.

6. 1. 3. Tệp Python “đã biên dịch”¶

Để tăng tốc độ tải các mô-đun, Python lưu trữ phiên bản đã biên dịch của từng mô-đun trong thư mụ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'
47 dưới 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'
48, trong đó phiên bản mã hóa định dạng của tệp đã biên dịch; . Ví dụ: trong bản phát hành CPython 3. 3 phiên bản biên dịch của thư rác. py sẽ được lưu vào bộ nhớ cache dưới 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'
49. 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 Python khác nhau 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 đã biên dịch để xem nó có lỗi thời và cần biên dịch lại không. Đâ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 độc lập với nền tảng, do đó, cùng một thư viện có thể được chia sẻ giữa các hệ thống 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 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 phải nguồn (chỉ được biên dịch), mô-đun đã 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ố lời khuyên cho các chuyên gia

  • Bạn có thể sử dụng công tắ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'
    
    90 hoặ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'
    
    91 trên lệnh Python để giảm kích thước của mô-đun đã biên dịch. Công tắ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'
    
    90 loại bỏ câu lệnh khẳng định, công tắ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'
    
    91 loại bỏ cả câu lệnh khẳng định và chuỗi __doc__. Vì một số chương trình có thể dựa vào việc có sẵn những thứ này, bạn chỉ nên sử dụng tùy chọn này nếu bạn biết mình đang làm gì. Các mô-đun “Được tối ưu hóa” có thẻ
    >>> 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'
    
    94 và thường nhỏ hơn. Các bản phát hành trong tương lai có thể thay đổi tác động của việc 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

    >>> 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'
    
    95 so với khi nó được đọc từ 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'
    
    7;

  • 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'
    
    98 có thể tạo. 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

6. 2. Mô-đun tiêu chuẩn¶

Python đi kèm với một thư viện gồm các mô-đun tiêu chuẩn, được mô tả trong một tài liệu riêng, Tham khảo thư viện Python (“Tham khảo thư viện” sau đây). Một số mô-đun được tích hợp vào trình thông dịch; . 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

>>> 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'
99 chỉ được cung cấp trên hệ thống Windows. Một mô-đun cụ thể đáng được chú ý.
>>> 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'
30, được tích hợp trong mọi trình thông dịch Python. Các 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'
31 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'
32 xác định các chuỗi được sử dụng làm lời nhắc chính và phụ

>>> import fibo
2

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

>>> 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 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
>>> 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'
42 hoặc từ một mặc định tích hợp sẵn 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'
42 không được đặt. Bạn có thể sửa đổi nó bằng các thao tác danh sách tiêu chuẩn

>>> import fibo
3

6. 3. Hàm >>> 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¶

Hàm tích hợp sẵ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'
36 được sử dụng để tìm ra tên mà một mô-đun xác định. Nó trả về một danh sách các chuỗi được sắp xếp

>>> import fibo
4

Không có đối số,

>>> 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 liệt kê các tên bạn đã xác định hiện tại

>>> import fibo
5

Lưu ý rằng nó liệt kê tất cả các loại tên. biến, mô-đun, hàm, v.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'
36 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 có một danh sách những thứ đó, chúng được xác định trong mô-đun chuẩ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'
60

>>> import fibo
6

6. 4. Gói¶

Các gói là một cách cấu trúc không gian tên mô-đun của Python bằng cách sử dụng “tên mô-đun chấm”. Ví dụ: tên 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'
61 chỉ định mô-đun con 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'
62 trong gói 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'
63. Giống như việc sử dụng các mô-đun giúp tác giả của các mô-đun khác nhau không phải lo lắng về tên biến toàn cục của nhau, việc sử dụng tên mô-đun chấm giúp 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 tập hợp các mô-đun (một “gói”) để 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 (ví dụ: thường được nhận dạng bằng phần mở rộng của chú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'
64,
>>> 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'
65,
>>> 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'
66), vì vậy bạn có thể cần tạo và duy trì bộ sưu tập mô-đun ngày càng tăng để chuyển đổi giữa các định dạng tệp khác nhau. Ngoài ra còn có nhiều thao tác 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 tiếng vang, áp dụng chức năng bộ chỉnh âm, tạo hiệu ứng âm thanh nổi nhân tạo), vì vậy, ngoài ra, bạn sẽ viết một luồng mô-đun không bao giờ kết thúc để thực hiện . Đây là cấu trúc có thể có cho gói của bạn (được thể hiện dưới dạng hệ thống tệp phân cấp)

>>> import fibo
7

Khi nhập gói, Python tìm kiếm thông qua các thư mục trê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'
40 để tìm thư mục con của gói

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'
68 được yêu cầu để Python xử lý các thư mục chứa tệp dưới dạng các gói. Điều này ngăn các thư mục có 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'
69, vô tình ẩn các mô-đun hợp lệ xảy ra sau này 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'
68 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'
91, được mô tả sau

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

>>> import fibo
8

Điều này tải submodule

>>> 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'
92. Nó phải được tham chiếu với tên đầy đủ của nó

>>> import fibo
9

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'
0

Đ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'
93 và làm cho nó khả dụng mà không cần tiền tố gói của nó, vì vậy 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'
1

Tuy nhiên, một biến thể khác là nhập trực tiếp hàm hoặc biến mong muố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'
2

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'
93, 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'
95 có sẵn trực tiế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'
3

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'
96, mục có thể là 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. Câu lệnh
>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3 đầu tiên kiểm tra xem mục đó có được xác định trong gói hay không; . Nếu 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'
98 sẽ được đưa ra

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'
99, mỗi mục trừ mục cuối cùng phải là một gói;

6. 4. 1. Nhập * Từ Gói¶

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

>>> import fibo
00? . Quá trình này có thể mất nhiều thời gian và việc nhập mô-đun con có thể có các tác dụng phụ không mong muốn chỉ xảy ra khi mô-đun con được nhập rõ ràng

Giải pháp duy nhất là tác giả gói cung cấp chỉ mục rõ ràng của gói. Câu lệnh

>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3 sử dụng quy ước sau. nếu mã
>>> 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'
68 của một gói xác định một danh sách có tên 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'
91, thì nó được coi là danh sách các tên mô-đun sẽ được nhập khi gặp phải
>>> import fibo
04. Tác giả gói có nhiệm vụ cập nhật danh sách này khi phiên bản mới của gói được phát hành. 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
>>> import fibo
05 có thể chứa đoạn mã 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'
4

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

>>> import fibo
00 sẽ nhập ba mô hình con có tên của gói
>>> import fibo
07

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'
91 không được xác định, câu lệnh
>>> import fibo
00 không nhập tất cả các mô hình con từ gói
>>> import fibo
07 vào không gian tên hiện tạ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'
68. 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
>>> fib = fibo.fib
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3 trước đó. Hãy xem xét mã này

>>> 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

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'
93 và
>>> import fibo
16 được nhập vào không gian tên hiện tại vì chúng được xác định trong gói
>>> import fibo
07 khi câu lệnh
>>> import fibo
18 đượ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'
91 đượ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 tuân theo các mẫu nhất định khi bạn sử dụng

>>> import fibo
20, nhưng đây vẫn được coi là thông lệ không tốt trong mã sản xuất

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

>>> import fibo
21. Trên thực tế, đây là ký hiệu được khuyến nghị trừ khi mô-đun nhập cần sử dụng các mô-đun con có cùng tên từ các gói khác nhau

6. 4. 2. Tham chiếu trong gói¶

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

>>> import fibo
22 trong ví dụ), bạn có thể sử dụng nhập khẩu tuyệt đối để chỉ các mô-đun con của các gói anh chị em. Ví dụ: nếu mô-đun
>>> import fibo
23 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'
93 trong gói
>>> import fibo
07, thì nó có thể sử dụng
>>> import fibo
26

Bạn cũng có thể viết nhập khẩu tương đối, với mẫu báo cáo nhập khẩu

>>> import fibo
27. Các lần nhập này sử dụng các dấu chấm ở đầu để biểu thị các gói hiện tại và gói gốc liên quan đến quá trình nhập tương đối. Ví dụ, từ mô-đun
>>> import fibo
16, bạ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'
6

Lưu ý rằng nhập tương đối 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à

>>> 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'
26, nên các mô-đun được sử dụng làm mô-đun chính của ứng dụng Python phải luôn sử dụng nhập tuyệt đối

6. 4. 3. Gói trong nhiều thư mục¶

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

>>> import fibo
30. Đ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 chứ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'
68 trước khi mã trong tệp đó được thực thi. Biến này có thể được sửa đổi;

Mặc dù tính năng này thường 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

Trên thực tế, các định nghĩa hàm cũng là 'các câu lệnh' được 'thực thi';