Đường dẫn python tồn tại

mô-đun

con trăn. thuật ngữ org định nghĩa mô-đun như sau

Một đối tượng phục vụ như một đơn vị tổ chức của mã Python. Các mô-đun có một không gian tên chứa các đối tượng Python tùy ý. Các mô-đun được tải vào Python bằng quá trình nhập. [Nguồn]

Trong thực tế, một mô-đun thường tương ứng với một tệp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Sức mạnh thực sự của các mô-đun là chúng có thể được nhập và sử dụng lại trong mã khác. Xem xét ví dụ sau

>>>

>>> import math
>>> math.pi
3.141592653589793

Trong dòng đầu tiên,

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Lưu ý rằng bạn viết

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Không gian tên là một ý tưởng tuyệt vời—hãy làm nhiều hơn thế nữa. [Nguồn]

Bạn có thể liệt kê nội dung của một không gian tên với

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bạn đã thấy cách sử dụng đơn giản nhất của

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Đoạn mã sau chỉ nhập biến

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Lưu ý rằng nơi này đặt

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bạn cũng có thể đổi tên các mô-đun và thuộc tính khi chúng được nhập

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Để biết thêm chi tiết về cú pháp nhập mô-đun, hãy xem Mô-đun và Gói Python – Giới thiệu

gói

Bạn có thể sử dụng một gói để tổ chức thêm các mô-đun của mình. con trăn. thuật ngữ org định nghĩa gói như sau

Một mô-đun Python có thể chứa các mô-đun con hoặc đệ quy, các gói con. Về mặt kỹ thuật, một gói là một mô-đun Python có thuộc tính

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

65. [Nguồn]

Lưu ý rằng một gói vẫn là một mô-đun. Là người dùng, bạn thường không cần phải lo lắng về việc bạn đang nhập mô-đun hay gói

Trong thực tế, một gói thường tương ứng với một thư mục tệp chứa các tệp Python và các thư mục khác. Để tự tạo một gói Python, bạn tạo một thư mục và một tệp có tên

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ghi chú. Các thư mục không có tệp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Nói chung, các mô-đun con và gói con không được nhập khi bạn nhập một gói. Tuy nhiên, bạn có thể sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Mỗi tệp quốc gia in ra một lời chào, trong khi tệp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Lưu ý rằng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Hãy chơi với gói

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> math.pi
3.141592653589793

Khi

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> math.pi
3.141592653589793

Tệp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Hãy nhớ rằng, nhập một mô-đun vừa tải nội dung vừa tạo một không gian tên chứa nội dung. Một vài ví dụ cuối cùng cho thấy rằng cùng một mô-đun có thể là một phần của các không gian tên khác nhau

Chi tiết kỹ thuật. Không gian tên mô-đun được triển khai dưới dạng từ điển Python và có sẵn tại thuộc tính

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bạn hiếm khi cần tương tác trực tiếp với

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Tương tự, không gian tên toàn cục của Python cũng là một từ điển. Bạn có thể truy cập nó thông qua

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Việc nhập các gói con và mô-đun con trong tệp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Nhập khẩu tuyệt đối và tương đối

Nhớ lại mã nguồn của

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bạn đã từng thấy các câu lệnh của

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Dấu chấm đề cập đến gói hiện tại và câu lệnh là một ví dụ về nhập tương đối. Bạn có thể đọc nó là “Từ gói hiện tại, nhập gói phụ

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Có một câu lệnh nhập tuyệt đối tương đương trong đó bạn đặt tên rõ ràng cho gói hiện tại

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Trên thực tế, tất cả các lần nhập trong

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Nhập tương đối phải ở dạng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Hướng dẫn kiểu PEP 8 khuyến nghị sử dụng nhập khẩu tuyệt đối nói chung. Tuy nhiên, nhập khẩu tương đối là một giải pháp thay thế để tổ chức phân cấp gói. Để biết thêm thông tin, hãy xem Nhập tuyệt đối và tương đối trong Python

Đường dẫn nhập của Python

Làm cách nào để Python tìm thấy các mô-đun và gói mà nó nhập? . Hiện tại, chỉ cần biết rằng Python tìm kiếm các mô-đun và gói trong đường dẫn nhập của nó. Đây là danh sách các vị trí được tìm kiếm các mô-đun để nhập

Ghi chú. Khi bạn nhập

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Cụ thể, nó sẽ tìm kiếm trong bộ đệm mô-đun để xem liệu

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bạn sẽ tìm hiểu thêm về bộ máy nhập Python đầy đủ trong phần sau

Bạn có thể kiểm tra đường dẫn nhập của Python bằng cách in

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

1. Thư mục của tập lệnh hiện tại [hoặc thư mục hiện tại nếu không có tập lệnh nào, chẳng hạn như khi Python đang chạy tương tác]
2. Nội dung của biến môi trường

   >>> import math
   >>> dir[]
   ['__annotations__', '__builtins__', ..., 'math']
   
   >>> dir[math]
   ['__doc__', ..., 'nan', 'pi', 'pow', ...]
   

   103
3. Các thư mục phụ thuộc vào cài đặt khác

Thông thường, Python sẽ bắt đầu ở đầu danh sách các vị trí và tìm kiếm một mô-đun nhất định ở mỗi vị trí cho đến khi khớp đầu tiên. Vì thư mục tập lệnh hoặc thư mục hiện tại luôn ở vị trí đầu tiên trong danh sách này, nên bạn có thể đảm bảo rằng các tập lệnh của mình tìm thấy các mô-đun và gói tự tạo bằng cách tổ chức các thư mục của bạn và cẩn thận về việc bạn chạy Python từ thư mục nào

Tuy nhiên, bạn cũng nên cẩn thận rằng bạn không tạo các mô-đun che khuất hoặc ẩn các mô-đun quan trọng khác. Ví dụ, giả sử bạn xác định mô-đun

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Sử dụng mô-đun này hoạt động như mong đợi

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Nhưng mô-đun này cũng phủ bóng mô-đun

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Vấn đề là Python hiện tìm kiếm mô-đun

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Để tránh những loại sự cố này, bạn nên cẩn thận với tên của các mô-đun và gói của mình. Cụ thể, tên gói và mô-đun cấp cao nhất của bạn phải là duy nhất. Nếu

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Thí dụ. Cấu trúc nhập khẩu của bạn

Mặc dù có thể tổ chức quá trình nhập của bạn bằng cách sử dụng thư mục hiện tại cũng như bằng cách thao tác với

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ứng dụng sẽ tạo lại cấu trúc tệp đã cho bằng cách tạo thư mục và tệp trống. Tệp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Hai tệp mã nguồn cũng như tệp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bây giờ hãy xem mã nguồn. Chức năng chính của ứng dụng được xác định trong

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Trong các dòng 12 đến 16, bạn đọc đường dẫn gốc từ dòng lệnh. Trong ví dụ trên bạn sử dụng dấu chấm, có nghĩa là thư mục hiện tại. Đường dẫn này sẽ được sử dụng làm

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Công việc thực tế xảy ra ở dòng 19 đến 23. Trước tiên, bạn tạo một đường dẫn duy nhất,

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Để thao tác với các đường dẫn như thế này,

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Trên dòng 26, bạn gọi

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Lưu ý rằng bạn nhập

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Hãy xem lại việc nhập

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Nó trông khá ngây thơ. Tuy nhiên, khi dự án phát triển, dòng này sẽ khiến bạn đau đầu. Mặc dù bạn nhập

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

May mắn thay, thư mục chứa tập lệnh hiện tại luôn nằm trong đường dẫn nhập của Python, vì vậy hiện tại nó hoạt động tốt. Tuy nhiên, nếu dự án của bạn đạt được một số lực kéo, thì nó có thể được sử dụng theo những cách khác

Ví dụ: ai đó có thể muốn nhập tập lệnh vào Jupyter Notebook và chạy tập lệnh từ đó. Hoặc họ có thể muốn sử dụng lại thư viện

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Để xem ví dụ, bạn có thể làm theo hướng dẫn PyInstaller và tạo một điểm vào cho ứng dụng của mình. Thêm một thư mục bổ sung bên ngoài thư mục ứng dụng của bạn

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Trong thư mục bên ngoài, tạo tập lệnh điểm vào,

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Tập lệnh này sẽ nhập

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Về lý thuyết, điều này sẽ hoạt động tương tự như chạy ứng dụng trực tiếp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Tại sao nó không hoạt động?

Vấn đề là khi khởi động ứng dụng bằng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Một giải pháp khả thi là thay đổi đường dẫn nhập của Python

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Điều này hoạt động vì đường dẫn nhập bao gồm thư mục chứa

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Trên thực tế, bạn đang tạo lại một tính năng của các phiên bản Python đầu tiên được gọi là nhập tương đối ngầm định. Chúng đã bị xóa khỏi ngôn ngữ bởi PEP 328 với lý do sau

Trong Python 2. 4 trở về trước, nếu bạn đang đọc một mô-đun nằm bên trong một gói, thì không rõ liệu

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

151 đề cập đến một mô-đun cấp cao nhất hay một mô-đun khác bên trong gói. Khi thư viện của Python mở rộng, ngày càng có nhiều mô-đun bên trong gói hiện có đột nhiên che khuất các mô-đun thư viện tiêu chuẩn một cách tình cờ. Đây là một vấn đề đặc biệt khó khăn bên trong các gói vì không có cách nào để chỉ định mô-đun nào có nghĩa là. [Nguồn]

Một giải pháp khác là sử dụng nhập tương đối thay thế. Thay đổi quá trình nhập trong

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Giờ đây, bạn có thể bắt đầu ứng dụng của mình thông qua tập lệnh nhập cảnh

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Thật không may, bạn không còn có thể gọi ứng dụng trực tiếp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Vấn đề là các lần nhập tương đối được giải quyết khác nhau trong các tập lệnh so với các mô-đun đã nhập. Tất nhiên, bạn có thể quay lại và khôi phục quá trình nhập tuyệt đối trước khi chạy tập lệnh trực tiếp hoặc thậm chí bạn có thể thực hiện một số động tác nhào lộn

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Thậm chí còn có một bản hack bị xử phạt chính thức để làm cho hoạt động nhập tương đối trong các tập lệnh. Thật không may, điều này cũng buộc bạn phải thay đổi

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Phải có cách tốt hơn. [Nguồn]

Thật vậy, một giải pháp tốt hơn—và ổn định hơn—là sử dụng cùng với hệ thống nhập và đóng gói của Python và cài đặt dự án của bạn dưới dạng gói cục bộ bằng cách sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Tạo và cài đặt gói cục bộ

Khi bạn cài đặt một gói từ PyPI, gói đó có sẵn cho tất cả các tập lệnh trong môi trường của bạn. Tuy nhiên, bạn cũng có thể cài đặt các gói từ máy tính cục bộ của mình và chúng cũng sẽ được cung cấp theo cách tương tự

Tạo một gói cục bộ không liên quan đến nhiều chi phí. Đầu tiên, tạo các tệp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Về lý thuyết,

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Một mẹo là cung cấp cho tất cả các gói cục bộ như vậy một tiền tố chung như

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Lệnh này sẽ cài đặt gói vào hệ thống của bạn.

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ghi chú. Loại tệp thiết lập này hoạt động rất tốt khi bạn tự làm việc với các dự án. Tuy nhiên, nếu bạn định chia sẻ mã với người khác thì bạn nên thêm một số thông tin khác vào tệp thiết lập của mình

Để biết thêm chi tiết về các tệp thiết lập, hãy xem Cách xuất bản Gói Python mã nguồn mở lên PyPI

Giờ đây,

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Điều này sẽ hoạt động bất kể bạn kết thúc cuộc gọi ứng dụng của mình như thế nào

Mẹo. Trong mã của riêng bạn, bạn nên tách biệt các tập lệnh và thư viện một cách có ý thức. Đây là một quy tắc tốt

• Một kịch bản có nghĩa là để được chạy
• Một thư viện có nghĩa là được nhập khẩu

Bạn có thể có mã mà bạn muốn tự chạy và nhập từ các tập lệnh khác. Trong trường hợp đó, thường đáng để cấu trúc lại mã của bạn để bạn chia phần chung thành một mô-đun thư viện

Mặc dù nên tách biệt các tập lệnh và thư viện, nhưng tất cả các tệp Python đều có thể được thực thi và nhập. Trong phần sau, bạn sẽ tìm hiểu thêm về cách tạo các mô-đun xử lý tốt cả hai

Gói không gian tên

Các mô-đun và gói Python có liên quan rất chặt chẽ với các tệp và thư mục. Điều này khiến Python khác biệt với nhiều ngôn ngữ lập trình khác, trong đó các gói chỉ hoạt động như các không gian tên mà không thực thi cách tổ chức mã nguồn. Xem các cuộc thảo luận trong PEP 402 để biết ví dụ

Các gói không gian tên đã có sẵn trong Python kể từ phiên bản 3. 3. Chúng ít phụ thuộc vào hệ thống phân cấp tệp cơ bản. Đặc biệt, các gói không gian tên có thể được chia thành nhiều thư mục. Gói không gian tên được tạo tự động nếu bạn có một thư mục chứa tệp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ghi chú. Nói chính xác, các gói không gian tên ẩn đã được giới thiệu trong Python 3. 3. Trong các phiên bản trước của Python, bạn có thể tạo thủ công các gói không gian tên theo một số cách không tương thích khác nhau. PEP 420 thống nhất và đơn giản hóa các phương pháp trước đó

Để hiểu rõ hơn về lý do tại sao các gói không gian tên có thể hữu ích, hãy thử triển khai một. Như một ví dụ thúc đẩy, bạn sẽ có một cách khác để giải quyết vấn đề trong Mẫu phương thức xuất xưởng và triển khai của nó trong Python. được cung cấp một đối tượng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Để cụ thể hơn, bạn muốn triển khai mã hoạt động giống như thế này

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Giả sử rằng bạn may mắn và bắt gặp một triển khai của bên thứ ba cho một số định dạng mà bạn cần sắp xếp theo thứ tự và nó được tổ chức dưới dạng gói không gian tên

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Tệp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Giao diện bộ nối tiếp này có một chút hạn chế, nhưng nó sẽ đủ để chứng minh cách các gói không gian tên hoạt động

Tệp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Lưu ý rằng cả hai lớp này đều triển khai cùng một giao diện với các phương thức

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Sau đó, bạn tạo một lớp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Một

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Giả sử rằng bạn đã cài đặt gói

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bằng cách cung cấp các đối tượng nối tiếp khác nhau cho

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ghi chú. Bạn có thể nhận được một ________ 2183 hoặc một ________ 2184 khi tự chạy mã. Điều này là do

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Càng xa càng tốt. Tuy nhiên, bây giờ bạn nhận ra rằng bạn cũng cần chuyển đổi các bài hát của mình sang biểu diễn YAML, không được hỗ trợ trong thư viện của bên thứ ba. Nhập sự kỳ diệu của các gói không gian tên. bạn có thể thêm

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Đầu tiên, tạo một thư mục trên hệ thống tệp cục bộ của bạn có tên là

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Trong tệp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Vì YAML và JSON có các định dạng khá giống nhau nên bạn có thể sử dụng lại hầu hết việc triển khai của

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Lưu ý rằng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Tiếp tục ví dụ trên, bây giờ bạn cũng có thể chuyển đổi bài hát sang YAML

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Cũng giống như các gói và mô-đun thông thường, các gói không gian tên phải được tìm thấy trên đường dẫn nhập Python. Nếu bạn đang làm theo các ví dụ trước, thì bạn có thể đã gặp sự cố với việc Python không tìm thấy

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ghi chú. Trong ví dụ ban đầu, việc lựa chọn bộ nối tiếp được thực hiện linh hoạt hơn. Bạn sẽ thấy cách sử dụng các gói không gian tên theo mẫu phương thức xuất xưởng thích hợp sau này

Bạn cũng nên đảm bảo rằng thư viện cục bộ của mình có sẵn như một gói thông thường. Như đã giải thích ở trên, bạn có thể thực hiện việc này bằng cách chạy Python từ thư mục thích hợp hoặc bằng cách sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Trong ví dụ này, bạn đang kiểm tra cách tích hợp gói bên thứ ba giả mạo với gói cục bộ của mình. Nếu

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ngoài ra, bạn có thể gây rối với đường dẫn nhập của mình. Đặt các thư mục

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Giờ đây, bạn có thể sử dụng tất cả các bộ nối tiếp mà không phải lo lắng về việc chúng được xác định trong gói của bên thứ ba hay cục bộ

Hướng dẫn phong cách nhập khẩu

PEP 8, hướng dẫn kiểu Python, có một số đề xuất về nhập. Như mọi khi với Python, giữ cho mã của bạn vừa có thể đọc được vừa có thể bảo trì là một điều quan trọng cần cân nhắc. Dưới đây là một số quy tắc chung về cách tạo kiểu cho hàng nhập của bạn

• Giữ nhập ở đầu tệp
• Viết nhập trên các dòng riêng biệt
• Tổ chức nhập khẩu thành các nhóm. nhập thư viện tiêu chuẩn đầu tiên, sau đó nhập của bên thứ ba và cuối cùng là nhập thư viện hoặc ứng dụng cục bộ
• Đặt hàng nhập khẩu theo thứ tự bảng chữ cái trong mỗi nhóm
• Thích nhập khẩu tuyệt đối hơn nhập khẩu tương đối
• Tránh nhập ký tự đại diện như

  >>> import math
  >>> dir[]
  ['__annotations__', '__builtins__', ..., 'math']
  
  >>> dir[math]
  ['__doc__', ..., 'nan', 'pi', 'pow', ...]
  

  408

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Đây là một ví dụ về phần nhập bên trong gói trình đọc nguồn cấp Python thực

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Lưu ý cách nhóm này làm cho các phụ thuộc của mô-đun này rõ ràng.

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Có những trường hợp nên bẻ cong các quy tắc này một chút. Bạn đã thấy rằng nhập tương đối có thể là một giải pháp thay thế cho việc tổ chức phân cấp gói. Sau này, bạn sẽ thấy trong một số trường hợp, bạn có thể di chuyển quá trình nhập vào định nghĩa hàm để phá vỡ các chu kỳ nhập như thế nào

Giới thiệu

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

417

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Điều này có một vài lợi thế. Bằng cách sử dụng lại hệ thống nhập, bạn sẽ có cách xử lý nhất quán hơn với các tệp bên trong các gói của mình. Nó cũng cho phép bạn truy cập dễ dàng hơn vào các tệp tài nguyên trong các gói khác. Các tài liệu tổng hợp nó độc đáo

Nếu bạn có thể nhập một gói, bạn có thể truy cập các tài nguyên trong gói đó. [Nguồn]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Backport tương thích với Python 2. 7 cũng như Python 3. 4 và các phiên bản mới hơn

Có một yêu cầu khi sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ví dụ đầu tiên, giả sử bạn có tài nguyên bên trong một gói như thế này

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Sau đó, bạn có thể sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ghi chú. Để liên tục quay lại sử dụng backport trên các phiên bản Python cũ hơn, bạn có thể nhập

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Xem phần mẹo và thủ thuật của hướng dẫn này để biết thêm thông tin

Phần còn lại của phần này sẽ hiển thị một số ví dụ phức tạp về việc sử dụng tệp tài nguyên trong thực tế

Thí dụ. Sử dụng tệp dữ liệu

Là một ví dụ đầy đủ hơn về việc sử dụng tệp dữ liệu, bạn sẽ thấy cách triển khai chương trình đố vui dựa trên dữ liệu dân số của Liên hợp quốc. Đầu tiên, tạo gói

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Mở tệp CSV và xem dữ liệu

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Mỗi dòng chứa dân số của một quốc gia trong một năm nhất định và một biến thể nhất định, cho biết loại kịch bản nào được sử dụng để chiếu. Tệp chứa dự báo dân số cho đến năm 2100

Hàm sau đọc tệp này và chọn ra tổng dân số của mỗi quốc gia cho một

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Các dòng được đánh dấu cho biết cách sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Hàm trên trả về một từ điển có số dân

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bạn có thể thực hiện bất kỳ điều thú vị nào với từ điển dân số này, bao gồm phân tích và trực quan hóa. Tại đây, bạn sẽ tạo một trò chơi đố vui yêu cầu người dùng xác định quốc gia nào trong nhóm đông dân nhất. Chơi trò chơi sẽ giống như thế này

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Các chi tiết của việc triển khai nằm quá xa chủ đề của hướng dẫn này, vì vậy chúng sẽ không được thảo luận ở đây. Tuy nhiên, bạn có thể mở rộng phần bên dưới để xem mã nguồn hoàn chỉnh

Mã nguồn của bài kiểm tra dân sốHiển thị/Ẩn

Bài kiểm tra dân số bao gồm hai chức năng, một chức năng đọc dữ liệu dân số như bạn đã làm ở trên và một chức năng chạy bài kiểm tra thực tế

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Lưu ý rằng ở dòng 24, bạn cũng kiểm tra xem ________ 2442 có nhỏ hơn ________ 2443 không. Các vị trí có

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Thí dụ. Thêm biểu tượng vào GUI Tkinter

Khi xây dựng giao diện người dùng đồ họa [GUI], bạn thường cần bao gồm các tệp tài nguyên như biểu tượng. Ví dụ sau đây cho thấy cách bạn có thể làm điều đó bằng cách sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ví dụ sử dụng Tkinter, một gói GUI có sẵn trong thư viện chuẩn. Nó dựa trên hệ thống cửa sổ Tk, ban đầu được phát triển cho ngôn ngữ lập trình Tcl. Có nhiều gói GUI khác có sẵn cho Python. Nếu bạn đang sử dụng một ứng dụng khác, thì bạn có thể thêm các biểu tượng vào ứng dụng của mình bằng các ý tưởng tương tự như những ý tưởng được trình bày ở đây

Trong Tkinter, hình ảnh được xử lý bởi lớp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Hãy nhớ rằng, khi phân phối gói của bạn, bạn thậm chí không đảm bảo rằng các tệp tài nguyên sẽ tồn tại dưới dạng tệp vật lý trên hệ thống tệp.

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Để đảm bảo mọi tệp tạm thời được dọn sạch đúng cách, bạn nên sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Đối với ví dụ đầy đủ, giả sử bạn có hệ thống phân cấp tệp sau

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Nếu bạn muốn tự mình thử ví dụ, thì bạn có thể tải xuống các tệp này cùng với phần còn lại của mã nguồn được sử dụng trong hướng dẫn này bằng cách nhấp vào liên kết bên dưới

Lấy mã nguồn. Nhấp vào đây để lấy mã nguồn mà bạn sẽ sử dụng để tìm hiểu về hệ thống nhập Python trong hướng dẫn này

Mã được lưu trữ trong một tệp có tên đặc biệt

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Để biết thêm thông tin về cách gọi gói bằng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

GUI được định nghĩa trong một lớp có tên là

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Nếu bạn muốn tìm hiểu thêm về cách xây dựng GUI với Tkinter, hãy xem Lập trình GUI Python với Tkinter. Tài liệu chính thức cũng có một danh sách tài nguyên hay để bắt đầu và hướng dẫn tại TkDocs là một tài nguyên tuyệt vời khác cho biết cách sử dụng Tk trong các ngôn ngữ khác

Ghi chú. Một nguyên nhân gây nhầm lẫn và thất vọng khi làm việc với hình ảnh trong Tkinter là bạn phải đảm bảo hình ảnh không được thu gom rác. Do cách Python và Tk tương tác, trình thu gom rác trong Python [ít nhất là trong CPython] không đăng ký rằng hình ảnh được sử dụng bởi

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Để đảm bảo rằng hình ảnh được lưu giữ xung quanh, bạn nên thêm tham chiếu đến chúng theo cách thủ công. Bạn có thể xem các ví dụ về điều này trong đoạn mã trên ở dòng 18 và 31

Sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

469

Cho đến giờ, bạn đã sử dụng từ khóa

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Trong mỗi trường hợp, mô-đun được nhập động bởi

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Thí dụ. Phương thức xuất xưởng với các gói không gian tên

Nghĩ lại ví dụ về serializers trước đó. Với

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Thêm mã sau vào gói không gian tên

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> math.pi
3.141592653589793

Nhà máy

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Nhà máy đưa ra một số giả định mạnh mẽ về cách đặt tên của cả mô-đun và lớp chứa các bộ nối tiếp riêng lẻ. Trong phần tiếp theo, bạn sẽ tìm hiểu về kiến ​​trúc plugin cho phép linh hoạt hơn

Bây giờ bạn có thể tạo lại ví dụ trước đó như sau

>>>

>>> import math
>>> math.pi
3.141592653589793

Trong trường hợp này, bạn không cần phải nhập rõ ràng từng bộ nối tiếp nữa. Thay vào đó, bạn chỉ định tên của bộ nối tiếp bằng một chuỗi. Chuỗi thậm chí có thể được chọn bởi người dùng của bạn khi chạy

Ghi chú. Trong một gói thông thường, bạn có thể đã triển khai

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Tuy nhiên, các gói không gian tên không được phép sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ví dụ cuối cùng cho thấy rằng bạn cũng nhận được một thông báo lỗi phù hợp nếu bạn cố gắng tuần tự hóa thành một định dạng chưa được triển khai

Thí dụ. Một gói plugin

Hãy xem một ví dụ khác về việc sử dụng nhập động. Bạn có thể sử dụng mô-đun sau để thiết lập kiến ​​trúc plugin linh hoạt trong mã của mình. Điều này tương tự như ví dụ trước, trong đó bạn có thể cắm các bộ nối tiếp cho các định dạng khác nhau bằng cách thêm các mô-đun mới

Một ứng dụng sử dụng plugin hiệu quả là công cụ trực quan hóa khám phá Keo. Keo có thể đọc được nhiều định dạng dữ liệu khác nhau. Tuy nhiên, nếu định dạng dữ liệu của bạn không được hỗ trợ thì bạn có thể viết trình tải dữ liệu tùy chỉnh của riêng mình

Bạn làm điều này bằng cách thêm một chức năng mà bạn trang trí và đặt ở một vị trí đặc biệt để Keo dễ dàng tìm thấy. Bạn không cần thay đổi bất kỳ phần nào của mã nguồn Keo. Xem tài liệu để biết tất cả các chi tiết

Bạn có thể thiết lập kiến ​​trúc plugin tương tự mà bạn có thể sử dụng trong các dự án của riêng mình. Trong kiến ​​trúc, có hai cấp độ

1. Gói plugin là tập hợp các plugin có liên quan tương ứng với gói Python
2. Plugin là một hành vi tùy chỉnh có sẵn trong mô-đun Python

Mô-đun

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> math.pi
3.141592653589793

Các chức năng của nhà máy được sử dụng để thêm chức năng vào các gói plugin một cách thuận tiện. Bạn sẽ thấy một số ví dụ về cách chúng được sử dụng trong thời gian ngắn

Xem xét tất cả các chi tiết của mã này nằm ngoài phạm vi của hướng dẫn này. Nếu quan tâm, bạn có thể xem cách triển khai bằng cách mở rộng phần bên dưới

Mã nguồn hoàn chỉnh của plugin. pyHiện/Ẩn

Đoạn mã sau cho thấy việc triển khai

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> math.pi
3.141592653589793

Việc triển khai này được đơn giản hóa một chút. Đặc biệt, nó không thực hiện bất kỳ xử lý lỗi rõ ràng nào. Kiểm tra dự án PyPlugs để triển khai đầy đủ hơn

Bạn có thể thấy rằng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Hãy xem xét một số ví dụ về cách sử dụng plugin. Ví dụ đầu tiên là gói

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Giả sử bạn có gói

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> math.pi
3.141592653589793

Mỗi mô-đun

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> math.pi
3.141592653589793

Để tìm hiểu thêm về các công cụ trang trí và cách chúng được sử dụng, hãy xem Primer on Python Decorators

Ghi chú. Để đơn giản hóa việc khám phá và nhập plugin, tên của mỗi plugin dựa trên tên của mô-đun chứa nó thay vì tên chức năng. Điều này hạn chế bạn chỉ có một plugin cho mỗi tệp

Để hoàn tất việc thiết lập

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> math.pi
3.141592653589793

Bây giờ bạn có thể sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> math.pi
3.141592653589793

Lưu ý rằng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bạn cũng có thể linh hoạt hơn trong việc chọn plugin để gọi. Trong ví dụ sau, bạn chọn ngẫu nhiên plugin. Tuy nhiên, bạn cũng có thể chọn plugin dựa trên tệp cấu hình hoặc đầu vào của người dùng

>>>

>>> import math
>>> math.pi
3.141592653589793

Để khám phá và gọi các plugin khác nhau, bạn cần nhập chúng. Hãy xem nhanh cách

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> math.pi
3.141592653589793

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

1. Hệ thống nhập của Python đảm bảo rằng mỗi plugin chỉ được nhập một lần

2. >>> import math
   >>> dir[]
   ['__annotations__', '__builtins__', ..., 'math']
   
   >>> dir[math]
   ['__doc__', ..., 'nan', 'pi', 'pow', ...]
   

   497 trình trang trí được xác định bên trong mỗi mô-đun plugin đăng ký từng plugin đã nhập
3. Trong quá trình triển khai đầy đủ, cũng sẽ có một số xử lý lỗi để xử lý các plugin bị thiếu

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

1. >>> import math
   >>> dir[]
   ['__annotations__', '__builtins__', ..., 'math']
   
   >>> dir[math]
   ['__doc__', ..., 'nan', 'pi', 'pow', ...]
   

   110 từ

   >>> import math
   >>> dir[]
   ['__annotations__', '__builtins__', ..., 'math']
   
   >>> dir[math]
   ['__doc__', ..., 'nan', 'pi', 'pow', ...]
   

   417 liệt kê tất cả các tệp bên trong một gói
2. Các kết quả được lọc để tìm các plugin tiềm năng
3. Mỗi tệp Python không bắt đầu bằng dấu gạch dưới được nhập
4. Các plugin trong bất kỳ tệp nào được phát hiện và đăng ký

Hãy kết thúc phần này với phiên bản cuối cùng của gói không gian tên serializers. Một vấn đề nổi bật là nhà máy

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Đầu tiên, thêm một dòng đăng ký từng bộ nối tiếp. Đây là một ví dụ về cách nó được thực hiện trong bộ nối tiếp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> math.pi
3.141592653589793

Tiếp theo, cập nhật

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> math.pi
3.141592653589793

Bạn triển khai

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Để biết thêm thông tin về cách sử dụng plugin, hãy xem PyPlugs trên PyPI và các Trình cắm. Thêm tính linh hoạt vào bản trình bày Ứng dụng của bạn từ PyCon 2019

Nhập nội bộ

Chi tiết về hệ thống nhập Python được mô tả trong tài liệu chính thức. Ở cấp độ cao, có ba điều xảy ra khi bạn nhập một mô-đun [hoặc gói]. mô-đun là

1. Tìm kiếm
2. Nạp vào
3. Bị ràng buộc vào một không gian tên

Đối với các thao tác nhập thông thường—những thao tác được thực hiện với câu lệnh

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Chẳng hạn, các phương pháp nhập và đổi tên

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> math.pi
3.141592653589793

Tất nhiên, trong mã bình thường, bạn nên chọn cái trước

Một điều cần lưu ý là, ngay cả khi bạn chỉ nhập một thuộc tính từ mô-đun, toàn bộ mô-đun sẽ được tải và thực thi. Phần còn lại của nội dung mô-đun không bị ràng buộc với không gian tên hiện tại. Một cách để chứng minh điều này là xem cái được gọi là bộ đệm mô-đun

>>>

>>> import math
>>> math.pi
3.141592653589793

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bộ đệm mô-đun đóng một vai trò rất quan trọng trong hệ thống nhập Python. Nơi đầu tiên Python tìm kiếm các mô-đun khi thực hiện nhập là trong

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Đây là một tối ưu hóa tuyệt vời, nhưng nó cũng là một điều cần thiết. Nếu các mô-đun được tải lại mỗi khi chúng được nhập, thì bạn có thể gặp phải tình trạng không nhất quán trong một số trường hợp nhất định, chẳng hạn như khi mã nguồn cơ bản thay đổi trong khi tập lệnh đang chạy

Nhớ lại đường dẫn nhập mà bạn đã thấy trước đó. Về cơ bản, nó cho Python biết nơi tìm kiếm các mô-đun. Tuy nhiên, nếu Python tìm thấy một mô-đun trong bộ đệm mô-đun, thì nó sẽ không bận tâm tìm kiếm đường dẫn nhập cho mô-đun

Thí dụ. Singletons như các mô-đun

Trong lập trình hướng đối tượng, một singleton là một lớp có nhiều nhất một thể hiện. Mặc dù có thể triển khai các singleton trong Python, nhưng thay vào đó, hầu hết các cách sử dụng tốt các singleton có thể được xử lý bởi các mô-đun. Bạn có thể tin tưởng bộ đệm mô-đun để khởi tạo một lớp chỉ một lần

Ví dụ: hãy quay lại dữ liệu dân số của Liên hợp quốc mà bạn đã xem trước đó. Mô-đun sau định nghĩa một lớp bao bọc dữ liệu dân số

>>> import math
>>> math.pi
3.141592653589793

Đọc dữ liệu từ đĩa mất một thời gian. Vì bạn không muốn tệp dữ liệu thay đổi, nên bạn khởi tạo lớp khi bạn tải mô-đun. Tên của lớp bắt đầu bằng dấu gạch dưới để cho người dùng biết rằng họ không nên sử dụng nó

Bạn có thể sử dụng đơn lẻ

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> math.pi
3.141592653589793

Điều này tạo ra một biểu đồ như sau

Lưu ý rằng việc tải dữ liệu tại thời điểm nhập là một loại phản mẫu. Lý tưởng nhất là bạn muốn hàng nhập khẩu của mình không có tác dụng phụ nhất có thể. Cách tiếp cận tốt hơn là tải dữ liệu một cách lười biếng khi bạn cần. Bạn có thể làm điều này khá tao nhã bằng cách sử dụng các thuộc tính. Mở rộng phần sau để xem ví dụ

Tải dữ liệu dân số một cách lười biếngHiển thị/Ẩn

Việc triển khai lười biếng của

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> math.pi
3.141592653589793

Bây giờ dữ liệu sẽ không được tải khi nhập. Thay vào đó, nó sẽ được nhập vào lần đầu tiên bạn truy cập từ điển

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Tải lại mô-đun

Bộ đệm mô-đun có thể hơi khó chịu khi bạn đang làm việc trong trình thông dịch tương tác. Tải lại một mô-đun sau khi bạn thay đổi nó không phải là chuyện nhỏ. Ví dụ: hãy xem mô-đun sau

>>> import math
>>> math.pi
3.141592653589793

Là một phần của quá trình thử nghiệm và gỡ lỗi mô-đun này, bạn nhập nó vào bảng điều khiển Python

>>>

>>> import math
>>> math.pi
3.141592653589793

Giả sử bạn nhận ra rằng bạn có một lỗi trong mã của mình, vì vậy bạn cập nhật tệp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> math.pi
3.141592653589793

Quay trở lại bảng điều khiển của bạn, bạn nhập mô-đun đã cập nhật để xem hiệu quả của bản sửa lỗi của bạn

>>>

>>> import math
>>> math.pi
3.141592653589793

Tại sao câu trả lời vẫn là

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Giải pháp đơn giản nhất cho vấn đề này là thoát khỏi bảng điều khiển Python và khởi động lại nó. Điều này buộc Python cũng phải xóa bộ đệm mô-đun của nó

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Tuy nhiên, khởi động lại trình thông dịch không phải lúc nào cũng khả thi. Bạn có thể đang ở trong một phiên phức tạp hơn khiến bạn mất nhiều thời gian để thiết lập. Nếu đúng như vậy, bạn có thể sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Lưu ý rằng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Trình tìm và Trình tải

Bạn đã thấy trước đó rằng việc tạo các mô-đun có cùng tên với các thư viện tiêu chuẩn có thể gây ra sự cố. Ví dụ: nếu bạn có một tệp có tên

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Điều này không phải luôn luôn như vậy, mặc dù. Tạo một tệp có tên

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Tiếp theo, mở trình thông dịch Python và nhập mô-đun mới này

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Một cái gì đó kỳ lạ đã xảy ra. Có vẻ như Python không nhập mô-đun

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bạn có thể thấy rằng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ghi chú. Các mô-đun tích hợp được biên dịch thành trình thông dịch Python. Thông thường, chúng là các mô-đun nền tảng như

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Hãy tìm hiểu sâu hơn về hệ thống nhập của Python. Điều này cũng sẽ cho thấy lý do tại sao các mô-đun tích hợp không bị che khuất bởi các mô-đun cục bộ. Có một số bước liên quan khi nhập một mô-đun

1. Python kiểm tra xem mô-đun có sẵn trong bộ đệm mô-đun không. Nếu

   >>> import math
   >>> dir[]
   ['__annotations__', '__builtins__', ..., 'math']
   
   >>> dir[math]
   ['__doc__', ..., 'nan', 'pi', 'pow', ...]
   

   121 chứa tên của mô-đun, thì mô-đun đó đã có sẵn và quá trình nhập kết thúc

2. Python bắt đầu tìm kiếm mô-đun bằng một số công cụ tìm. Một công cụ tìm sẽ tìm kiếm mô-đun bằng một chiến lược nhất định. Công cụ tìm mặc định có thể nhập các mô-đun tích hợp, mô-đun cố định và mô-đun trên đường dẫn nhập

3. Python tải mô-đun bằng trình tải. Trình tải nào Python sử dụng được xác định bởi công cụ tìm định vị mô-đun và được chỉ định trong một thứ gọi là thông số mô-đun

Bạn có thể mở rộng hệ thống nhập Python bằng cách triển khai công cụ tìm của riêng bạn và, nếu cần, trình tải của riêng bạn. Bạn sẽ thấy một ví dụ hữu ích hơn về công cụ tìm sau. Hiện tại, bạn sẽ học cách thực hiện các tùy chỉnh cơ bản [và có thể ngớ ngẩn] của hệ thống nhập

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Đầu tiên, lưu ý rằng điều này trả lời câu hỏi từ trước đó. các mô-đun tích hợp không bị che khuất bởi các mô-đun cục bộ vì công cụ tìm tích hợp được gọi trước công cụ tìm đường dẫn nhập, tìm các mô-đun cục bộ. Thứ hai, lưu ý rằng bạn có thể tùy chỉnh

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Để nhanh chóng làm rối phiên Python của bạn, bạn có thể xóa tất cả các công cụ tìm

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Vì không có công cụ tìm, Python không thể tìm hoặc nhập các mô-đun mới. Tuy nhiên, Python vẫn có thể nhập các mô-đun đã có trong bộ đệm mô-đun vì nó tìm ở đó trước khi gọi bất kỳ công cụ tìm nào

Trong ví dụ trên,

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Sau đây là một ví dụ hữu ích hơn một chút. Bạn sẽ viết một công cụ tìm in thông báo tới bảng điều khiển xác định mô-đun đang được nhập. Ví dụ này cho thấy cách thêm công cụ tìm của riêng bạn, mặc dù nó không thực sự cố gắng tìm một mô-đun

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Tất cả các công cụ tìm phải triển khai một phương thức lớp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

1. Bằng cách trả lại

   >>> import math
   >>> dir[]
   ['__annotations__', '__builtins__', ..., 'math']
   
   >>> dir[math]
   ['__doc__', ..., 'nan', 'pi', 'pow', ...]
   

   153 nếu nó không biết cách tìm và tải mô-đun
2. Bằng cách trả về thông số mô-đun chỉ định cách tải mô-đun
3. Bằng cách tăng

   >>> import math
   >>> dir[]
   ['__annotations__', '__builtins__', ..., 'math']
   
   >>> dir[math]
   ['__doc__', ..., 'nan', 'pi', 'pow', ...]
   

   183 để cho biết rằng không thể nhập mô-đun

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ghi chú. Vì Python hoàn toàn trả về

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bằng cách chèn

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ví dụ: bạn có thể thấy rằng việc nhập

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Ví dụ khác, giả sử bạn đang thực hiện nhiệm vụ loại bỏ thế giới của các biểu thức thông thường. [Bây giờ, tại sao bạn lại muốn một thứ như vậy? Cụm từ thông dụng thật tuyệt. ] Bạn có thể triển khai công cụ tìm sau cấm mô-đun biểu thức chính quy

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Nâng cao một

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Mặc dù bạn chỉ đang nhập

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Thí dụ. Tự động cài đặt từ PyPI

Vì hệ thống nhập của Python đã khá mạnh mẽ và hữu ích, nên có nhiều cách để làm rối tung nó hơn là mở rộng nó theo cách hữu ích. Tuy nhiên, ví dụ sau có thể hữu ích trong một số trường hợp

Chỉ mục gói Python [PyPI] là cửa hàng pho mát duy nhất của bạn để tìm các gói và mô-đun của bên thứ ba. Đây cũng là nơi mà các gói tải xuống của

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Trong các hướng dẫn Real Python khác, bạn có thể đã xem hướng dẫn sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Cảnh báo. Trong hầu hết các trường hợp, sẽ không tuyệt lắm nếu Python tự động cài đặt các mô-đun. Chẳng hạn, trong hầu hết các cài đặt sản xuất, bạn muốn kiểm soát môi trường của mình. Hơn nữa, tài liệu cảnh báo không nên sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Để tránh làm rối cài đặt Python của bạn, bạn chỉ nên sử dụng mã này trong các môi trường mà bạn không ngại xóa hoặc cài đặt lại

Công cụ tìm sau cố gắng cài đặt các mô-đun bằng cách sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

So với các công cụ tìm bạn đã thấy trước đó, công cụ này phức tạp hơn một chút. Bằng cách đặt công cụ tìm này cuối cùng trong danh sách công cụ tìm, bạn biết rằng nếu bạn gọi

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Cố gắng sử dụng thư viện

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Thông thường,

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Trong khi

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Điều này có thể gây hậu quả tai hại cho dự án của bạn

Một tình huống trong đó cài đặt tự động có thể khá hữu ích là khi bạn đang chạy Python trên đám mây với quyền kiểm soát hạn chế hơn đối với môi trường của bạn, chẳng hạn như khi bạn đang chạy sổ ghi chép kiểu Jupyter tại Google Colaboratory. Môi trường sổ ghi chép Colab rất phù hợp để thực hiện khám phá dữ liệu hợp tác

Một sổ ghi chép điển hình đi kèm với nhiều gói khoa học dữ liệu được cài đặt, bao gồm NumPy, Pandas và Matplotlib và bạn có thể thêm các gói mới bằng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Vì

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Thí dụ. Nhập tệp dữ liệu

Ví dụ cuối cùng trong phần này được lấy cảm hứng từ bài đăng trên blog tuyệt vời của Aleksey Bilogur Nhập hầu hết mọi thứ bằng Python. Giới thiệu về Trình tải và Trình tìm mô-đun. Bạn đã biết cách sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Trước đó, bạn đã làm việc với một tệp CSV khổng lồ chứa dữ liệu dân số. Để làm cho ví dụ về trình tải tùy chỉnh dễ quản lý hơn, hãy xem xét tệp

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Dòng đầu tiên là tiêu đề đặt tên cho ba trường và hai hàng dữ liệu tiếp theo, mỗi hàng chứa thông tin về một nhân viên. Để biết thêm thông tin về cách làm việc với tệp CSV, hãy xem Đọc và ghi tệp CSV bằng Python

Mục tiêu của bạn trong phần này là viết một công cụ tìm và một trình tải cho phép bạn nhập tệp CSV trực tiếp để bạn có thể viết mã như sau

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Công việc của công cụ tìm sẽ là tìm kiếm và nhận dạng các tệp CSV. Công việc của trình tải sẽ là nhập dữ liệu CSV. Thông thường, bạn có thể triển khai các trình tìm và trình tải tương ứng trong một lớp chung. Đó là cách tiếp cận bạn sẽ thực hiện ở đây

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Có khá nhiều mã trong ví dụ này. May mắn thay, hầu hết công việc được thực hiện trong

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Như bạn đã thấy trước đó,

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Đối với nhập cấp cao nhất,

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Dữ liệu CSV được tải bởi

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Chẳng hạn, thêm

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>>

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Nói chung, tên trường CSV có thể chứa khoảng trắng và các ký tự khác không được phép trong tên thuộc tính Python. Trước khi thêm các trường làm thuộc tính trên mô-đun, bạn làm sạch tên trường bằng biểu thức chính quy. Điều này được thực hiện trong

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bạn có thể xem ví dụ về hiệu ứng này trong tên trường

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bằng cách kết nối

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Xử lý các gói trên các phiên bản Python

Đôi khi bạn cần xử lý các gói có tên khác nhau tùy thuộc vào phiên bản Python. Bạn đã thấy một ví dụ về điều này.

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Miễn là các phiên bản khác nhau của gói tương thích, bạn có thể xử lý vấn đề này bằng cách đổi tên gói thành

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Trong phần còn lại của mã, bạn có thể tham khảo

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Thông thường, cách dễ nhất là sử dụng câu lệnh

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bạn có thể viết lại ví dụ trước như sau

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Điều này sẽ sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Xử lý các gói bị thiếu. Sử dụng một thay thế

Trường hợp sử dụng sau có liên quan chặt chẽ với ví dụ trước. Giả sử có một gói triển khai lại tương thích. Việc triển khai lại được tối ưu hóa tốt hơn, vì vậy bạn muốn sử dụng nó nếu có sẵn. Tuy nhiên, gói ban đầu có sẵn dễ dàng hơn và cũng mang lại hiệu suất chấp nhận được

Một ví dụ như vậy là

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Điều này sẽ sử dụng

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Một ví dụ tương tự khác là gói UltraJSON, một bộ mã hóa và giải mã JSON cực nhanh có thể được sử dụng để thay thế cho

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]

Bằng cách đổi tên

>>> import math
>>> dir[]
['__annotations__', '__builtins__', ..., 'math']

>>> dir[math]
['__doc__', ..., 'nan', 'pi', 'pow', ...]