Làm cách nào để nhập tất cả các mô-đun từ gói bằng Python?

Mô-đun Python. Tổng quan

Thực tế, có ba cách khác nhau để xác định một mô-đun trong Python

1. Một mô-đun có thể được viết bằng chính Python
2. Một mô-đun có thể được viết bằng C và được tải động trong thời gian chạy, như mô-đun

   >>> import mod
   >>> mod
   
   

   6 [biểu thức chính quy]
3. Mô-đun tích hợp về bản chất được chứa trong trình thông dịch, chẳng hạn như mô-đun

   >>> import mod
   >>> mod
   
   

   7

Nội dung của mô-đun được truy cập theo cùng một cách trong cả ba trường hợp. với câu lệnh

>>> import mod
>>> mod

Ở đây, trọng tâm chủ yếu sẽ là các mô-đun được viết bằng Python. Điều thú vị về các mô-đun được viết bằng Python là chúng cực kỳ đơn giản để xây dựng. Tất cả những gì bạn cần làm là tạo một tệp chứa mã Python hợp pháp, sau đó đặt tên cho tệp có phần mở rộng

>>> import mod
>>> mod

Ví dụ: giả sử bạn đã tạo một tệp có tên

>>> s
NameError: name 's' is not defined
>>> foo['quux']
NameError: name 'foo' is not defined

chế độ. py

s = "If Comrade Napoleon says it, it must be right."
a = [100, 200, 300]

def foo[arg]:
    print[f'arg = {arg}']

class Foo:
    pass

Một số đối tượng được định nghĩa trong

>>> s
NameError: name 's' is not defined
>>> foo['quux']
NameError: name 'foo' is not defined

• >>> s
  NameError: name 's' is not defined
  >>> foo['quux']
  NameError: name 'foo' is not defined
  

  2 [một chuỗi]

• >>> s
  NameError: name 's' is not defined
  >>> foo['quux']
  NameError: name 'foo' is not defined
  

  3 [một danh sách]

• >>> s
  NameError: name 's' is not defined
  >>> foo['quux']
  NameError: name 'foo' is not defined
  

  4 [một chức năng]

• >>> s
  NameError: name 's' is not defined
  >>> foo['quux']
  NameError: name 'foo' is not defined
  

  5 [một lớp]

Giả sử

>>> s
NameError: name 's' is not defined
>>> foo['quux']
NameError: name 'foo' is not defined

>>>

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

Đường dẫn tìm kiếm mô-đun

Tiếp tục với ví dụ trên, hãy xem điều gì sẽ xảy ra khi Python thực thi câu lệnh

import mod

Khi trình thông dịch thực hiện câu lệnh

>>> import mod
>>> mod

>>> s
NameError: name 's' is not defined
>>> foo['quux']
NameError: name 'foo' is not defined

• Thư mục chạy tập lệnh đầu vào hoặc thư mục hiện tại nếu trình thông dịch đang được chạy tương tác
• Danh sách các thư mục chứa trong biến môi trường, nếu nó được đặt. [Định dạng cho

  >>> s
  NameError: name 's' is not defined
  >>> foo['quux']
  NameError: name 'foo' is not defined
  

  9 phụ thuộc vào hệ điều hành nhưng phải bắt chước biến môi trường

  >>> mod.s
  'If Comrade Napoleon says it, it must be right.'
  >>> mod.foo['quux']
  arg = quux
  

  1. ]
• Danh sách các thư mục phụ thuộc vào cài đặt được định cấu hình tại thời điểm Python được cài đặt

Đường dẫn tìm kiếm kết quả có thể truy cập được trong biến Python

>>> mod.s
'If Comrade Napoleon says it, it must be right.'
>>> mod.foo['quux']
arg = quux

>>> mod.s
'If Comrade Napoleon says it, it must be right.'
>>> mod.foo['quux']
arg = quux

>>>

>>> import sys
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages']

Ghi chú. Nội dung chính xác của

>>> mod.s
'If Comrade Napoleon says it, it must be right.'
>>> mod.foo['quux']
arg = quux

Vì vậy, để đảm bảo tìm thấy mô-đun của bạn, bạn cần thực hiện một trong các thao tác sau

• Đặt

  >>> s
  NameError: name 's' is not defined
  >>> foo['quux']
  NameError: name 'foo' is not defined
  

  0 vào thư mục chứa tập lệnh đầu vào hoặc thư mục hiện tại, nếu tương tác
• Sửa đổi biến môi trường

  >>> s
  NameError: name 's' is not defined
  >>> foo['quux']
  NameError: name 'foo' is not defined
  

  9 để chứa thư mục chứa

  >>> s
  NameError: name 's' is not defined
  >>> foo['quux']
  NameError: name 'foo' is not defined
  

  0 trước khi bắt đầu trình thông dịch
  • Hoặc là. Đặt

    >>> s
    NameError: name 's' is not defined
    >>> foo['quux']
    NameError: name 'foo' is not defined
    

    0 vào một trong các thư mục đã có trong biến

    >>> s
    NameError: name 's' is not defined
    >>> foo['quux']
    NameError: name 'foo' is not defined
    

    9
• Đặt

  >>> s
  NameError: name 's' is not defined
  >>> foo['quux']
  NameError: name 'foo' is not defined
  

  0 vào một trong các thư mục phụ thuộc vào cài đặt mà bạn có thể có hoặc không có quyền ghi vào, tùy thuộc vào hệ điều hành

Thực sự có một tùy chọn bổ sung. bạn có thể đặt tệp mô-đun vào bất kỳ thư mục nào bạn chọn và sau đó sửa đổi

>>> mod.s
'If Comrade Napoleon says it, it must be right.'
>>> mod.foo['quux']
arg = quux

>>> s
NameError: name 's' is not defined
>>> foo['quux']
NameError: name 'foo' is not defined

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>>

>>> sys.path.append[r'C:\Users\john']
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages', 'C:\\Users\\john']
>>> import mod

Khi một mô-đun đã được nhập, bạn có thể xác định vị trí tìm thấy mô-đun bằng thuộc tính

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>>

>>> import mod
>>> mod.__file__
'C:\\Users\\john\\mod.py'

>>> import re
>>> re.__file__
'C:\\Python36\\lib\\re.py'

Phần thư mục của

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> mod.s
'If Comrade Napoleon says it, it must be right.'
>>> mod.foo['quux']
arg = quux

Tuyên bố

>>> import mod
>>> mod

8

Nội dung mô-đun được cung cấp cho người gọi với câu lệnh

>>> import mod
>>> mod

>>> import mod
>>> mod

import 

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> mod

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> mod

>>> s
NameError: name 's' is not defined
>>> foo['quux']
NameError: name 'foo' is not defined

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> s
NameError: name 's' is not defined
>>> foo['quux']
NameError: name 'foo' is not defined

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> mod.s
'If Comrade Napoleon says it, it must be right.'
>>> mod.foo['quux']
arg = quux

>>> import mod
>>> mod

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> mod

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> mod

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> mod

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> mod

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> mod

import mod

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

import mod

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> mod

import mod

import mod

Hàm

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

37

Hàm dựng sẵn

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>>

import mod

Lưu ý cách cuộc gọi đầu tiên tới

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

Điều này có thể hữu ích để xác định chính xác những gì đã được thêm vào không gian tên bằng một câu lệnh nhập

>>>

import mod

Khi đưa ra một đối số là tên của một mô-đun,

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>>

import mod

>>>

import mod

Thực thi một Mô-đun dưới dạng Tập lệnh

Bất kỳ tệp

>>> import mod
>>> mod

Đây một lần nữa là

>>> s
NameError: name 's' is not defined
>>> foo['quux']
NameError: name 'foo' is not defined

chế độ. py

s = "If Comrade Napoleon says it, it must be right."
a = [100, 200, 300]

def foo[arg]:
    print[f'arg = {arg}']

class Foo:
    pass

Điều này có thể được chạy như một kịch bản

import mod

Không có lỗi, vì vậy nó rõ ràng đã hoạt động. Cấp, nó không phải là rất thú vị. Khi nó được viết, nó chỉ định nghĩa các đối tượng. Nó không làm bất cứ điều gì với chúng và nó không tạo ra bất kỳ đầu ra nào

Hãy sửa đổi mô-đun Python ở trên để nó tạo ra một số đầu ra khi chạy dưới dạng tập lệnh

chế độ. py

>>> import sys
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages']

Bây giờ nó sẽ thú vị hơn một chút

>>> import sys
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages']

Thật không may, bây giờ nó cũng tạo đầu ra khi được nhập dưới dạng mô-đun

>>>

>>> import sys
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages']

Đây có lẽ không phải là những gì bạn muốn. Mô-đun không thường tạo đầu ra khi được nhập

Sẽ thật tuyệt nếu bạn có thể phân biệt giữa thời điểm tệp được tải dưới dạng mô-đun và khi tệp được chạy dưới dạng tập lệnh độc lập?

Hỏi và ngươi sẽ nhận được

Khi một tệp

>>> import mod
>>> mod

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

chế độ. py

>>> import sys
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages']

Bây giờ, nếu bạn chạy dưới dạng tập lệnh, bạn sẽ nhận được kết quả

>>> import sys
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages']

Nhưng nếu bạn nhập dưới dạng mô-đun, bạn không

>>>

>>> import sys
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages']

Các mô-đun thường được thiết kế với khả năng chạy dưới dạng tập lệnh độc lập nhằm mục đích kiểm tra chức năng có trong mô-đun. Điều này được gọi là thử nghiệm đơn vị. Ví dụ: giả sử bạn đã tạo một mô-đun

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

thực tế. py

>>> import sys
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages']

Tệp có thể được coi là một mô-đun và hàm

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>>

>>> import sys
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages']

Nhưng nó cũng có thể được chạy độc lập bằng cách chuyển một đối số số nguyên trên dòng lệnh để kiểm tra

>>> import sys
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages']

Tải lại một mô-đun

Vì lý do hiệu quả, một mô-đun chỉ được tải một lần cho mỗi phiên phiên dịch. Điều đó tốt cho các định nghĩa hàm và lớp, thường chiếm phần lớn nội dung của mô-đun. Nhưng một mô-đun cũng có thể chứa các câu lệnh thực thi, thường là để khởi tạo. Xin lưu ý rằng các câu lệnh này sẽ chỉ được thực thi khi lần đầu tiên một mô-đun được nhập

Xem xét tệp sau

>>> s
NameError: name 's' is not defined
>>> foo['quux']
NameError: name 'foo' is not defined

chế độ. py

>>> import sys
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages']

>>>

>>> sys.path.append[r'C:\Users\john']
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages', 'C:\\Users\\john']
>>> import mod

Câu lệnh

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

Nếu bạn thực hiện thay đổi đối với mô-đun và cần tải lại mô-đun đó, bạn cần khởi động lại trình thông dịch hoặc sử dụng chức năng có tên là

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>>

>>> sys.path.append[r'C:\Users\john']
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages', 'C:\\Users\\john']
>>> import mod

Gói Python

Giả sử bạn đã phát triển một ứng dụng rất lớn bao gồm nhiều mô-đun. Khi số lượng mô-đun tăng lên, việc theo dõi tất cả chúng trở nên khó khăn nếu chúng được đổ vào một vị trí. Điều này đặc biệt đúng nếu chúng có tên hoặc chức năng tương tự nhau. Bạn có thể muốn có một phương tiện để nhóm và tổ chức chúng

Các gói cho phép cấu trúc phân cấp của không gian tên mô-đun bằng cách sử dụng ký hiệu dấu chấm. Cũng giống như cách mà các mô-đun giúp tránh xung đột giữa các tên biến toàn cục, các gói giúp tránh xung đột giữa các tên mô-đun

Việc tạo một gói khá đơn giản vì nó sử dụng cấu trúc tệp phân cấp vốn có của hệ điều hành. Xét cách sắp xếp sau

Ở đây, có một thư mục tên là

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

mod1. py

>>> sys.path.append[r'C:\Users\john']
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages', 'C:\\Users\\john']
>>> import mod

mod2. py

>>> sys.path.append[r'C:\Users\john']
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages', 'C:\\Users\\john']
>>> import mod

Với cấu trúc này, nếu thư mục

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> mod.s
'If Comrade Napoleon says it, it must be right.'
>>> mod.foo['quux']
arg = quux

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>>

>>> sys.path.append[r'C:\Users\john']
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages', 'C:\\Users\\john']
>>> import mod

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>>

>>> sys.path.append[r'C:\Users\john']
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages', 'C:\\Users\\john']
>>> import mod

>>> sys.path.append[r'C:\Users\john']
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages', 'C:\\Users\\john']
>>> import mod

>>>

>>> sys.path.append[r'C:\Users\john']
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages', 'C:\\Users\\john']
>>> import mod

Bạn cũng có thể nhập các mô-đun với các câu lệnh này

>>> import mod
>>> mod.__file__
'C:\\Users\\john\\mod.py'

>>> import re
>>> re.__file__
'C:\\Python36\\lib\\re.py'

>>>

>>> import mod
>>> mod.__file__
'C:\\Users\\john\\mod.py'

>>> import re
>>> re.__file__
'C:\\Python36\\lib\\re.py'

Về mặt kỹ thuật, bạn cũng có thể nhập gói

>>>

>>> import mod
>>> mod.__file__
'C:\\Users\\john\\mod.py'

>>> import re
>>> re.__file__
'C:\\Python36\\lib\\re.py'

Nhưng điều này ít có ích. Mặc dù nói một cách nghiêm túc, đây là một câu lệnh Python đúng về mặt cú pháp, nhưng nó không làm được gì nhiều hữu ích. Cụ thể, nó không đặt bất kỳ mô-đun nào trong

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>>

>>> import mod
>>> mod.__file__
'C:\\Users\\john\\mod.py'

>>> import re
>>> re.__file__
'C:\\Python36\\lib\\re.py'

Để thực sự nhập các mô-đun hoặc nội dung của chúng, bạn cần sử dụng một trong các biểu mẫu được hiển thị ở trên

Khởi tạo gói

Nếu một tệp có tên

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

Ví dụ: xem xét tệp

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

__trong đó__. py

>>> import mod
>>> mod.__file__
'C:\\Users\\john\\mod.py'

>>> import re
>>> re.__file__
'C:\\Python36\\lib\\re.py'

Hãy thêm tệp này vào thư mục

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

Bây giờ khi gói được nhập, danh sách toàn cầu

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>>

>>> import mod
>>> mod.__file__
'C:\\Users\\john\\mod.py'

>>> import re
>>> re.__file__
'C:\\Python36\\lib\\re.py'

Một mô-đun trong gói có thể truy cập biến toàn cục bằng cách nhập lần lượt

mod1. py

>>> import mod
>>> mod.__file__
'C:\\Users\\john\\mod.py'

>>> import re
>>> re.__file__
'C:\\Python36\\lib\\re.py'

>>>

>>> import mod
>>> mod.__file__
'C:\\Users\\john\\mod.py'

>>> import re
>>> re.__file__
'C:\\Python36\\lib\\re.py'

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

__trong đó__. py

>>> import mod
>>> mod.__file__
'C:\\Users\\john\\mod.py'

>>> import re
>>> re.__file__
'C:\\Python36\\lib\\re.py'

sau đó khi bạn thực thi

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>>

>>> import mod
>>> mod.__file__
'C:\\Users\\john\\mod.py'

>>> import re
>>> re.__file__
'C:\\Python36\\lib\\re.py'

Ghi chú. Phần lớn tài liệu Python nói rằng tệp

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

Bắt đầu với Python 3. 3, Các gói không gian tên ẩn đã được giới thiệu. Những thứ này cho phép tạo một gói mà không cần bất kỳ tệp

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

Nhập khẩu

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

81 Từ một Gói hàng

Vì mục đích của cuộc thảo luận sau đây, gói được xác định trước đó được mở rộng để chứa một số mô-đun bổ sung

Hiện tại có bốn mô-đun được định nghĩa trong thư mục

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

mod1. py

>>> sys.path.append[r'C:\Users\john']
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages', 'C:\\Users\\john']
>>> import mod

mod2. py

>>> sys.path.append[r'C:\Users\john']
>>> sys.path
['', 'C:\\Users\\john\\Documents\\Python\\doc', 'C:\\Python36\\Lib\\idlelib',
'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib',
'C:\\Python36', 'C:\\Python36\\lib\\site-packages', 'C:\\Users\\john']
>>> import mod

mod3. py

import 

mod4. py

import 

[Trí tưởng tượng, phải không?]

Bạn đã thấy rằng khi

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>>

import 

Câu lệnh tương tự cho một gói là thế này

import 

Cái đó làm cái gì?

>>>

import 

Hừm. Không nhiều. Bạn có thể đã mong đợi [giả sử bạn có bất kỳ kỳ vọng nào] rằng Python sẽ đi sâu vào thư mục gói, tìm tất cả các mô-đun có thể và nhập tất cả chúng. Nhưng như bạn có thể thấy, theo mặc định, đó không phải là điều xảy ra

Thay vào đó, Python tuân theo quy ước này. nếu tệp

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

Đối với ví dụ hiện tại, giả sử bạn tạo một

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

pkg/__init__. py

import 

Bây giờ

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>>

import 

Sử dụng

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

Nhân tiện,

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

pkg/mod1. py

import 

Bây giờ, một câu lệnh

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>>

>>> import mod
>>> mod

>>> s
NameError: name 's' is not defined
>>> foo['quux']
NameError: name 'foo' is not defined

>>> s
NameError: name 's' is not defined
>>> foo['quux']
NameError: name 'foo' is not defined

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

Tóm lại,

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

• Đối với một gói, khi

  >>> import mod
  >>> print[mod.s]
  If Comrade Napoleon says it, it must be right.
  >>> mod.a
  [100, 200, 300]
  >>> mod.foo[['quux', 'corge', 'grault']]
  arg = ['quux', 'corge', 'grault']
  >>> x = mod.Foo[]
  >>> x
  
  

  85 không được xác định, thì

  >>> import mod
  >>> print[mod.s]
  If Comrade Napoleon says it, it must be right.
  >>> mod.a
  [100, 200, 300]
  >>> mod.foo[['quux', 'corge', 'grault']]
  arg = ['quux', 'corge', 'grault']
  >>> x = mod.Foo[]
  >>> x
  
  

  33 không nhập bất kỳ thứ gì
• Đối với một mô-đun, khi

  >>> import mod
  >>> print[mod.s]
  If Comrade Napoleon says it, it must be right.
  >>> mod.a
  [100, 200, 300]
  >>> mod.foo[['quux', 'corge', 'grault']]
  arg = ['quux', 'corge', 'grault']
  >>> x = mod.Foo[]
  >>> x
  
  

  85 không được xác định,

  >>> import mod
  >>> print[mod.s]
  If Comrade Napoleon says it, it must be right.
  >>> mod.a
  [100, 200, 300]
  >>> mod.foo[['quux', 'corge', 'grault']]
  arg = ['quux', 'corge', 'grault']
  >>> x = mod.Foo[]
  >>> x
  
  

  33 sẽ nhập mọi thứ [ngoại trừ—bạn đã đoán ra—các tên bắt đầu bằng dấu gạch dưới]

gói con

Các gói có thể chứa các gói con lồng nhau đến độ sâu tùy ý. Ví dụ: hãy thực hiện thêm một sửa đổi đối với thư mục gói ví dụ như sau

Bốn mô-đun [

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

import mod

import mod

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

import mod

import mod

Quá trình nhập vẫn hoạt động giống như được hiển thị trước đó. Cú pháp tương tự, nhưng ký hiệu dấu chấm bổ sung được sử dụng để tách tên gói khỏi tên gói phụ

>>>

>>> import mod
>>> mod

Ngoài ra, một mô-đun trong một gói con có thể tham chiếu các đối tượng trong gói con anh chị em [trong trường hợp anh chị em chứa một số chức năng mà bạn cần]. Ví dụ: giả sử bạn muốn nhập và thực thi hàm

>>> s
NameError: name 's' is not defined
>>> foo['quux']
NameError: name 'foo' is not defined

>>> import mod
>>> print[mod.s]
If Comrade Napoleon says it, it must be right.
>>> mod.a
[100, 200, 300]
>>> mod.foo[['quux', 'corge', 'grault']]
arg = ['quux', 'corge', 'grault']
>>> x = mod.Foo[]
>>> x

import mod

pkg/sub__pkg2/mod3. py

>>> import mod
>>> mod

>>>

>>> import mod
>>> mod

Hoặc bạn có thể sử dụng nhập tương đối, trong đó

import mod

import mod

import mod

• import mod
  

  18 đánh giá gói mẹ [

  >>> import mod
  >>> print[mod.s]
  If Comrade Napoleon says it, it must be right.
  >>> mod.a
  [100, 200, 300]
  >>> mod.foo[['quux', 'corge', 'grault']]
  arg = ['quux', 'corge', 'grault']
  >>> x = mod.Foo[]
  >>> x
  
  

  58] và

• import mod
  

  23 đánh giá thành gói con

  import mod
  

  13 của gói mẹ

pkg/sub__pkg2/mod3. py

>>> import mod
>>> mod

>>>

>>> import mod
>>> mod

Phần kết luận

Trong hướng dẫn này, bạn đã đề cập đến các chủ đề sau

• Cách tạo mô-đun Python
• Các vị trí mà trình thông dịch Python tìm kiếm một mô-đun
• Cách lấy quyền truy cập vào các đối tượng được xác định trong một mô-đun bằng câu lệnh

  >>> import mod
  >>> mod
  
  

  8
• Cách tạo mô-đun có thể thực thi dưới dạng tập lệnh độc lập
• Cách tổ chức các mô-đun thành các gói và gói con
• Cách kiểm soát việc khởi tạo gói

Tải xuống PDF miễn phí. Bảng cheat Python 3

Điều này hy vọng sẽ cho phép bạn hiểu rõ hơn về cách truy cập vào chức năng có sẵn trong nhiều mô-đun tích hợp và bên thứ ba có sẵn trong Python

Ngoài ra, nếu bạn đang phát triển ứng dụng của riêng mình, việc tạo các mô-đun và gói của riêng bạn sẽ giúp bạn tổ chức và mô-đun hóa mã của mình, giúp mã hóa, bảo trì và gỡ lỗi dễ dàng hơn

Nếu bạn muốn tìm hiểu thêm, hãy xem tài liệu sau tại Python. tổ chức

• Hệ thống

  >>> import mod
  >>> mod
  
  

  8
• hướng dẫn Python. mô-đun

Python hạnh phúc