Hướng dẫn python import - trăn nhập

Question

Trong quá trình viết code, chúng ta có thể sẽ cần đến một số mô-đun cụ thể. Thông thường, chúng ta hay nạp các mô-đun này vào dự án bằng 1 câu lệnh duy nhất.

Nội dung chính Show

6.1. Thêm về các mô -đunMore on Modules¶
6.1.1. Thực hiện các mô -đun dưới dạng tập lệnhExecuting modules as scripts¶
6.1.2. Đường dẫn tìm kiếm mô -đunThe Module Search Path¶
Khi bạn chạy một mô -đun Python với“Compiled” Python files¶
6.2. Mô -đun tiêu chuẩnStandard Modules¶
6.3. Hàm >>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 7The >>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 7 Function¶
6.4. GóiPackages¶
6.4.1. Nhập khẩu * từ GóiImporting * From a Package¶
6.4.2. Tài liệu tham khảo nội bộIntra-package References¶
6.4.3. Các gói trong nhiều thư mụcPackages in Multiple Directories¶

Vậy thì sẽ thế nào nếu ta chỉ biết được tên của mô-đun này tại runtime? Chúng ta sẽ nạp mô-đun đó vào dự án như thế nào? Hàm __import__() được tích hợp sẵn của Python có thể giúp bạn giải quyết được các băn khoăn này, nó giúp nạp các mô-đun vào dự án tại runtime.

Cú pháp: __import__(name, globals, locals, fromlist, level)

Giải thích các tham số:

– name: Tên của mô-đun muốn nạp vào dự án

– globals và locals: Các tên diễn giải

– formlist: Các đối tượng hoặc mô-đun phụ được nạp vào (dưới dạng một danh sách)

– level: Chỉ định liệu rằng sẽ sử dụng nạp vào tuyệt đối hay nạp vào tương đối. Mặc định là -1 (tuyệt đối và tương đối).

Ví dụ 1. Nạp vào mô-đun numpy, điều này tương tự với việc thực thi câu lệnh “import numpy”

# -----------------------------------------------------------
#Cafedev.vn - Kênh thông tin IT hàng đầu Việt Nam
#@author cafedevn
#Contact: 
#Fanpage: https://www.facebook.com/cafedevn
#Instagram: https://instagram.com/cafedevn
#Twitter: https://twitter.com/CafedeVn
#Linkedin: https://www.linkedin.com/in/cafe-dev-407054199/
#

# importing numpy module 
# it is equivalent to "import numpy" 
np = __import__('numpy', globals(), locals(), [], 0) 
  
# array from numpy 
a = np.array([1, 2, 3]) 
  
# prints the type 
print(type(a))

Kết quả in ra là:

Ví dụ 2. Cả hai câu lệnh sau đây đều có cùng một ý nghĩa, và thực hiện cùng một chức năng


# from numpy import complex as comp, array as arr 
np = __import__('numpy', globals(), locals(), ['complex', 'array'], 0) 
  
comp = np.complex
arr = np.array

Về việc ứng dụng hàm __import__()

Hàm __import__() không thực sự cần thiết trong lập trình Python. Việc trực tiếp sử dụng nó là rất hiếm thấy. Nhưng thi thoảng, khi cần nạp các mô-đun vào dự án tại runtime thì hàm này khá tiện dụng.

Nguồn và Tài liệu tiếng anh tham khảo:

w3school
python.org
geeksforgeeks

Tài liệu từ cafedev:

Full series tự học Python từ cơ bản tới nâng cao tại đây nha.
Ebook về python tại đây.
Các series tự học lập trình khác

Nếu bạn thấy hay và hữu ích, bạn có thể tham gia các kênh sau của cafedev để nhận được nhiều hơn nữa:

Group Facebook
Fanpage
Youtube
Instagram
Twitter
Linkedin
Pinterest
Trang chủ

Chào thân ái và quyết thắng!

Đăng ký kênh youtube để ủng hộ Cafedev nha các bạn, Thanks you!

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

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

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


# from numpy import complex as comp, array as arr 
np = __import__('numpy', globals(), locals(), ['complex', 'array'], 0) 
  
comp = np.complex
arr = np.array

8 được nối thêm. Trong một mô -đun, tên mô -đun (dưới dạng chuỗi) có sẵn dưới dạng giá trị của biến toàn cầu


# from numpy import complex as comp, array as arr 
np = __import__('numpy', globals(), locals(), ['complex', 'array'], 0) 
  
comp = np.complex
arr = np.array

9. Chẳng hạn, sử dụng trình soạn thảo văn bản yêu thích của bạn để tạo một tệp có tên

# Fibonacci numbers module

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

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

0 trong thư mục hiện tại với các nội dung sau:

# Fibonacci numbers module

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

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

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

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

# Fibonacci numbers module

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

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

1 trực tiếp vào không gian tên hiện tại (xem phạm vi Python và không gian tên để biết thêm chi tiết); Nó chỉ thêm tên mô -đun

# Fibonacci numbers module

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

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

1 ở đó. Sử dụng tên mô -đun, bạn có thể truy cập các chức năng:namespace (see Python Scopes and Namespaces for more details); it only adds the module name

# Fibonacci numbers module

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

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

1 there. Using the module name you can access the functions:

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

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

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

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

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

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

# Fibonacci numbers module

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

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

3.

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

# Fibonacci numbers module

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

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

4 khi bắt đầu một mô -đun (hoặc tập lệnh, cho vấn đề đó). Các tên mô -đun đã nhập, nếu được đặt ở cấp cao nhất của một mô -đun (bên ngoài bất kỳ chức năng hoặc lớp nào), sẽ được thêm vào không gian tên toàn cầu của mô -đun.

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

# Fibonacci numbers module

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

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

4 nhập tên từ một mô -đun trực tiếp vào không gian tên mô -đun nhập. Ví dụ:

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

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

# Fibonacci numbers module

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

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

1 không được xác định).

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

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

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

# Fibonacci numbers module

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

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

7). Trong hầu hết các trường hợp, các lập trình viên Python không sử dụng cơ sở này vì nó đưa một bộ tên không xác định vào trình thông dịch, có thể che giấu một số điều bạn đã xác định.

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

# Fibonacci numbers module

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

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

8 từ một mô -đun hoặc gói được cau mày, vì nó thường gây ra mã có thể đọc được kém. Tuy nhiên, việc sử dụng nó là ổn để lưu gõ trong các phiên tương tác.

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

# Fibonacci numbers module

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

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

9, thì tên sau

# Fibonacci numbers module

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

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

9 bị ràng buộc trực tiếp với mô -đun đã nhập.

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

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

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

1 sẽ làm, với sự khác biệt duy nhất của nó có sẵn là

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

2.

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

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

3 với các hiệu ứng tương tự:

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

Ghi chú

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

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

4, ví dụ:

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

5.

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

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

0

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


# from numpy import complex as comp, array as arr 
np = __import__('numpy', globals(), locals(), ['complex', 'array'], 0) 
  
comp = np.complex
arr = np.array

9 được đặt thành

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

7. Điều đó có nghĩa là bằng cách thêm mã này vào cuối mô -đun của bạn:

1

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

2

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

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

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

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

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

8 được nhập, trình thông dịch trước tiên tìm kiếm một mô-đun tích hợp với tên đó. Các tên mô -đun này được liệt kê trong

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

9. Nếu không tìm thấy, sau đó nó sẽ tìm kiếm một tệp có tên

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

0 trong danh sách các thư mục được đưa ra bởi biến

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

1.

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

1 được khởi tạo từ các vị trí này:

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

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

3 (danh sách các tên thư mục, có cùng cú pháp với biến shell

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

4).

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

4).

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

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

5, được xử lý bởi mô-đun

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

6).

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

Ghi chú

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

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

4, ví dụ:

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

5.not added to the module search path.

6.1.1. Thực hiện các mô -đun dưới dạng tập lệnhStandard Modules for more information.

Khi bạn chạy một mô -đun Python với“Compiled” Python files¶

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


# from numpy import complex as comp, array as arr 
np = __import__('numpy', globals(), locals(), ['complex', 'array'], 0) 
  
comp = np.complex
arr = np.array

9 được đặt thành

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

7. Điều đó có nghĩa là bằng cách thêm mã này vào cuối mô -đun của bạn:

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

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

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

Bạn có thể sử dụng các công tắc
```
>>> from fibo import fib, fib2
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
```
1 hoặc
```
>>> from fibo import fib, fib2
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
```
2 trên lệnh Python để giảm kích thước của một mô -đun được biên dịch. Chuyển đổi
```
>>> from fibo import fib, fib2
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
```
1 Xóa các câu lệnh ARPERT, công tắc
```
>>> from fibo import fib, fib2
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
```
2 sẽ loại bỏ cả hai câu lệnh ASPER và __DOC__. Vì một số chương trình có thể dựa vào việc có những thứ này có sẵn, bạn chỉ nên sử dụng tùy chọn này nếu bạn biết bạn đang làm gì. Các mô -đun tối ưu hóa có thể có thẻ
```
>>> from fibo import fib, fib2
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
```
5 và thường nhỏ hơn. Phát hành trong tương lai có thể thay đổi tác động của tối ưu hóa.

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

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

6 so với khi nó được đọc từ tệp


# from numpy import complex as comp, array as arr 
np = __import__('numpy', globals(), locals(), ['complex', 'array'], 0) 
  
comp = np.complex
arr = np.array

8; Điều duy nhất mà các tệp nhanh hơn về

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

6 là tốc độ mà chúng được tải.

Mô -đun
```
>>> from fibo import fib, fib2
>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
```
9 có thể tạo các tệp .pyc cho tất cả các mô -đun trong một thư mục.
Có nhiều chi tiết hơn về quy trình này, bao gồm biểu đồ dòng chảy của các quyết định, trong PEP 3147.PEP 3147.

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

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

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

0 chỉ được cung cấp trên các hệ thống Windows. Một mô -đun cụ thể xứng đáng được chú ý:

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

1, được xây dựng thành mọi phiên dịch viên Python. Các biến

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

2 và

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

3 Xác định các chuỗi được sử dụng làm lời nhắc chính và phụ:

3

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

Biến

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

1 là danh sách các chuỗi xác định đường dẫn tìm kiếm của trình thông dịch cho các mô -đun. Nó được khởi tạo thành một đường dẫn mặc định được lấy từ biến môi trường

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

3 hoặc từ mặc định tích hợp nếu

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

3 không được đặt. Bạn có thể sửa đổi nó bằng cách sử dụng các hoạt động danh sách tiêu chuẩn:

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

3, or from a built-in default if

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

3 is not set. You can modify it using standard list operations:

4

6.3. Hàm >>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 7The >>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 7 Function¶

Hàm tích hợp

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

7 được sử dụng để tìm ra tên nào một mô-đun xác định. Nó trả về một danh sách các chuỗi được sắp xếp:

5

Không có đối số,

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

7 liệt kê các tên bạn đã xác định hiện tại:

6

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

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

7 không liệt kê tên của các hàm và biến tích hợp. Nếu bạn muốn một danh sách những người đó, chúng được xác định trong mô -đun tiêu chuẩn

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

1:

7

6.4. GóiPackages¶

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

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

2 chỉ định một mô hình con có tên

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

3 trong một gói có tên

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

4. Giống như việc sử dụng các mô-đun giúp các tác giả của các mô-đun khác nhau phải lo lắng về các tên biến toàn cầu của nhau, việc sử dụng tên mô-đun chấm có lưu các tác giả của các gói đa mô-đun như Numpy hoặc Gối không phải lo lắng về tên mô-đun của nhau .

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

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

5,

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

6,

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

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

8

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

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

1 để tìm kiếm thư mục con.

Các tệp

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

9 được yêu cầu để làm cho các thư mục xử lý Python chứa tệp dưới dạng các gói. Điều này ngăn các thư mục có tên chung, chẳng hạn như

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

0, vô tình ẩn các mô -đun hợp lệ xảy ra sau đó trên đường dẫn tìm kiếm mô -đun. Trong trường hợp đơn giản nhất,

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

9 chỉ có thể là một tệp trống, nhưng nó cũng có thể thực thi mã khởi tạo cho gói hoặc đặt biến

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

2, được mô tả sau.

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

9

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

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

3. Nó phải được tham chiếu với tên đầy đủ của nó.


# from numpy import complex as comp, array as arr 
np = __import__('numpy', globals(), locals(), ['complex', 'array'], 0) 
  
comp = np.complex
arr = np.array

0

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


# from numpy import complex as comp, array as arr 
np = __import__('numpy', globals(), locals(), ['complex', 'array'], 0) 
  
comp = np.complex
arr = np.array

1

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

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

4 và cung cấp nó mà không có tiền tố gói của nó, do đó nó có thể được sử dụng như sau:


# from numpy import complex as comp, array as arr 
np = __import__('numpy', globals(), locals(), ['complex', 'array'], 0) 
  
comp = np.complex
arr = np.array

2

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


# from numpy import complex as comp, array as arr 
np = __import__('numpy', globals(), locals(), ['complex', 'array'], 0) 
  
comp = np.complex
arr = np.array

3

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

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

4, nhưng điều này làm cho chức năng của nó

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

6 có sẵn trực tiếp:


# from numpy import complex as comp, array as arr 
np = __import__('numpy', globals(), locals(), ['complex', 'array'], 0) 
  
comp = np.complex
arr = np.array

4

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

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

7, mục này có thể là một mô hình con (hoặc gói con) của gói hoặc một số tên khác được xác định trong gói, như hàm, lớp hoặc biến. Tuyên bố

# Fibonacci numbers module

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

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

4 đầu tiên kiểm tra xem mục được xác định trong gói; Nếu không, nó giả định nó là một mô -đun và cố gắng tải nó. Nếu nó không tìm thấy nó, một ngoại lệ

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

9 sẽ được nâng lên.

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

00, mỗi mục ngoại trừ phần cuối cùng phải là một gói; Mục cuối cùng có thể là một mô -đun hoặc gói nhưng có thể là một lớp hoặc chức năng hoặc biến được xác định trong mục trước.

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

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

01? Lý tưởng nhất, người ta sẽ hy vọng rằng điều này bằng cách nào đó đi ra khỏi hệ thống tập tin, tìm thấy những mô hình con nào có trong gói và nhập tất cả chúng. Điều này có thể mất nhiều thời gian và nhập các mô-đun phụ có thể có các tác dụng phụ không mong muốn chỉ nên xảy ra khi mô hình phụ được nhập rõ ràng.

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

# Fibonacci numbers module

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

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

4 sử dụng quy ước sau: Nếu mã ____ ____89 định nghĩa một danh sách có tên

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

2, thì nó được coi là danh sách các tên mô -đun nên được nhập khi gặp phải

05. Tùy thuộc vào gói tác giả để giữ cho danh sách này được cập nhật khi một phiên bản mới của gói được phát hành. Các tác giả gói cũng có thể quyết định không hỗ trợ nó, nếu họ không thấy việc sử dụng để nhập * từ gói của họ. Ví dụ: Tệp

06 có thể chứa mã sau:


# from numpy import complex as comp, array as arr 
np = __import__('numpy', globals(), locals(), ['complex', 'array'], 0) 
  
comp = np.complex
arr = np.array

5

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

01 sẽ nhập ba mô hình con được đặt tên của gói

08.

Nếu

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

2 không được xác định, câu lệnh

01 không nhập tất cả các mô hình con từ gói

08 vào không gian tên hiện tại; Nó chỉ đảm bảo rằng gói

08 đã được nhập (có thể đang chạy bất kỳ mã khởi tạo nào trong

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

9) và sau đó nhập bất kỳ tên nào được xác định trong gói. Điều này bao gồm bất kỳ tên nào được xác định (và các mô hình con được tải rõ ràng) bởi

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

9. Nó cũng bao gồm bất kỳ mô hình con nào của gói được tải rõ ràng bởi các câu lệnh

# Fibonacci numbers module

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

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

4 trước đó. Xem xét mã này:


# from numpy import complex as comp, array as arr 
np = __import__('numpy', globals(), locals(), ['complex', 'array'], 0) 
  
comp = np.complex
arr = np.array

6

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

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

4 và

17 được nhập trong không gian tên hiện tại vì chúng được xác định trong gói

08 khi câu lệnh

19 được thực thi. (Điều này cũng hoạt động khi

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

2 được xác định.)

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

21, nhưng nó vẫn được coi là thực tiễn xấu trong mã sản xuất.

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

22! Trên thực tế, đây là ký hiệu được đề xuất trừ khi mô -đun nhập cần sử dụng các mô hình con có cùng tên từ các gói khác nhau.

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

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

23 trong ví dụ), bạn có thể sử dụng nhập khẩu tuyệt đối để chỉ các mô hình con của các gói anh chị em. Ví dụ: nếu mô -đun

24 cần sử dụng mô -đun

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

4 trong gói

08, nó có thể sử dụng

27.

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

28 của báo cáo nhập khẩu. Các nhập khẩu này sử dụng các dấu chấm hàng đầu để chỉ ra các gói hiện tại và cha mẹ liên quan đến nhập khẩu tương đối. Ví dụ, từ mô -đun

17, bạn có thể sử dụng:


# from numpy import complex as comp, array as arr 
np = __import__('numpy', globals(), locals(), ['complex', 'array'], 0) 
  
comp = np.complex
arr = np.array

7

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

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

7, các mô -đun dự định sử dụng làm mô -đun chính của ứng dụng Python phải luôn sử dụng nhập khẩu tuyệt đối.

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

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

31. Điều này được khởi tạo để trở thành một danh sách chứa tên của thư mục giữ gói

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

9 trước khi mã trong tệp đó được thực thi. Biến này có thể được sửa đổi; Làm như vậy ảnh hưởng đến các tìm kiếm trong tương lai cho các mô -đun và thanh toán con có trong gói.

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

Chú thích

1

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

programming python __init__.py trong python Import in Python Python import Python library Import module Python Importlib Python

Hướng dẫn python __import__ - trăn __nhập__

Đăng ký kênh youtube để ủng hộ Cafedev nha các bạn, Thanks you!

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

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

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

Khi bạn chạy một mô -đun Python với“Compiled” Python files¶

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

6.3. Hàm >>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 7The >>> from fibo import * >>> fib(500) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 7 Function¶

6.4. GóiPackages¶

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

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

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

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

Hướng dẫn python import - trăn nhập