Lập trình mô-đun đề cập đến quá trình chia một nhiệm vụ lập trình lớn, khó sử dụng thành các nhiệm vụ hoặc mô-đun riêng biệt, nhỏ hơn, dễ quản lý hơn. Các mô-đun riêng lẻ sau đó có thể được ghép lại với nhau như các khối xây dựng để tạo ra một ứng dụng lớn hơn
Có một số lợi thế để mô đun hóa mã trong một ứng dụng lớn
Sự đơn giản. Thay vì tập trung vào toàn bộ vấn đề hiện tại, một mô-đun thường tập trung vào một phần tương đối nhỏ của vấn đề. Nếu bạn đang làm việc trên một mô-đun duy nhất, bạn sẽ có một miền vấn đề nhỏ hơn để xoay sở. Điều này làm cho việc phát triển dễ dàng hơn và ít bị lỗi hơn
khả năng bảo trì. Các mô-đun thường được thiết kế sao cho chúng thực thi các ranh giới logic giữa các miền vấn đề khác nhau. Nếu các mô-đun được viết theo cách giảm thiểu sự phụ thuộc lẫn nhau, thì sẽ giảm khả năng sửa đổi một mô-đun sẽ có tác động đến các phần khác của chương trình. (Bạn thậm chí có thể thực hiện các thay đổi đối với một mô-đun mà không cần biết bất kỳ kiến thức nào về ứng dụng bên ngoài mô-đun đó. ) Điều này làm cho một nhóm gồm nhiều lập trình viên có thể làm việc cộng tác trên một ứng dụng lớn trở nên khả thi hơn
khả năng tái sử dụng. Có thể dễ dàng sử dụng lại chức năng được xác định trong một mô-đun duy nhất (thông qua giao diện được xác định phù hợp) bởi các phần khác của ứng dụng. Điều này giúp loại bỏ nhu cầu sao chép mã
phạm vi. Các mô-đun thường xác định một không gian tên riêng biệt, giúp tránh xung đột giữa các mã định danh trong các khu vực khác nhau của chương trình. (Một trong những nguyên lý trong Zen of Python là 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. )
Các chức năng, mô-đun và gói đều là các cấu trúc trong Python thúc đẩy quá trình mô đun hóa mã
Tải xuống PDF miễn phí. Bảng cheat Python 3
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
Một mô-đun có thể được viết bằng chính Python
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
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
6 (biểu thức chính quy)
Một mô-đun tích hợp về bản chất được chứa trong trình thông dịch, như mô-đun
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
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
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
8
Ở đâ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
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
9. Đó là nó. Không có cú pháp đặc biệt hoặc voodoo là cần thiết
Ví dụ: giả sử bạn đã tạo một tệp có tên
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
0 chứa các nội dung sau
chế độ. py
s="If Comrade Napoleon says it, it must be right."a=[100,200,300]deffoo(arg):print(f'arg = {arg}')classFoo:pass
Một số đối tượng được định nghĩa trong
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
0
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
2 (một chuỗi)
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
3 (một danh sách)
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
4 (một chức năng)
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
5 (một lớp)
Giả sử
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
0 ở một vị trí thích hợp mà bạn sẽ sớm tìm hiểu thêm, những đối tượng này có thể được truy cập bằng cách nhập mô-đun như sau
>>>
>>> importmod>>> 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.Foo object at 0x03C181F0>
Loại bỏ các quảng cáo
Đườ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
importmod
Khi trình thông dịch thực hiện câu lệnh
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
8 ở trên, nó sẽ tìm kiếm
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
0 trong danh sách các thư mục được tập hợp từ các nguồn sau
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
>>> sNameError: 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
2, được lấy từ một mô-đun có tên
>>> 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
2 phụ thuộc vào cài đặt. Phần trên gần như chắc chắn sẽ trông hơi khác trên máy tính của bạn
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
>>> sNameError: 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
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
9 để chứa thư mục chứa
>>> sNameError: 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
>>> sNameError: 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
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
9
Đặt
>>> sNameError: 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
2 trong thời gian chạy để nó chứa thư mục đó. Ví dụ, trong trường hợp này, bạn có thể đặt
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
0 trong thư mục
>>> importmod>>> 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.Foo object at 0x03C181F0>
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
>>> importmod>>> 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.Foo object at 0x03C181F0>
>>> importmod>>> 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.Foo object at 0x03C181F0>
04 phải là một trong các thư mục trong
>>> mod.s'If Comrade Napoleon says it, it must be right.'>>> mod.foo('quux')arg = quux
2
Tuyên bố >>> import mod
>>> mod
<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
8
Nội dung mô-đun được cung cấp cho người gọi với câu lệnh
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
8. Câu lệnh
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
8 có nhiều dạng khác nhau, được hiển thị bên dướ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
<mod.Foo object at 0x03C181F0>
10
Hình thức đơn giản nhất là hình thức đã được hiển thị ở trên
import<module_name>
Lưu ý rằng điều này không làm cho nội dung mô-đun có thể truy cập trực tiếp vào người gọi. Mỗi mô-đun có bảng ký hiệu riêng, đóng vai trò là bảng ký hiệu chung cho tất cả các đối tượng được xác định trong mô-đun. Do đó, một mô-đun tạo một không gian tên riêng, như đã lưu ý
Tuyên bố
>>> importmod>>> 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.Foo object at 0x03C181F0>
10 chỉ đặt
>>> importmod>>> 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.Foo object at 0x03C181F0>
12 trong bảng ký hiệu của người gọi. Các đối tượng được xác định trong mô-đun vẫn còn trong bảng ký hiệu riêng của mô-đun
Từ người gọi, các đối tượng trong mô-đun chỉ có thể truy cập được khi có tiền tố là
>>> importmod>>> 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.Foo object at 0x03C181F0>
12 thông qua ký hiệu dấu chấm, như minh họa bên dưới
Sau câu lệnh
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
8 sau đây,
>>> importmod>>> 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.Foo object at 0x03C181F0>
15 được đặt vào bảng ký hiệu cục bộ. Do đó,
>>> importmod>>> 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.Foo object at 0x03C181F0>
15 có ý nghĩa trong ngữ cảnh địa phương của người gọi
>>>
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
Nhưng
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
2 và
>>> importmod>>> 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.Foo object at 0x03C181F0>
18 vẫn nằm trong bảng ký hiệu riêng của mô-đun và không có ý nghĩa trong ngữ cảnh địa phương
>>>
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
Để được truy cập trong ngữ cảnh cục bộ, tên của các đối tượng được xác định trong mô-đun phải có tiền tố là
>>> importmod>>> 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.Foo object at 0x03C181F0>
15
>>>
>>> mod.s'If Comrade Napoleon says it, it must be right.'>>> mod.foo('quux')arg = quux
Một số mô-đun được phân tách bằng dấu phẩy có thể được chỉ định trong một câu lệnh
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
8
>>> importmod>>> 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.Foo object at 0x03C181F0>
0Loại bỏ các quảng cáo
>>> 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.Foo object at 0x03C181F0>
21
Một dạng thay thế của câu lệnh
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
8 cho phép các đối tượng riêng lẻ từ mô-đun được nhập trực tiếp vào bảng ký hiệu của người gọi
>>> importmod>>> 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.Foo object at 0x03C181F0>
1
Sau khi thực hiện câu lệnh trên,
>>> importmod>>> 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.Foo object at 0x03C181F0>
23 có thể được tham chiếu trong môi trường của người gọi mà không cần tiền tố
>>> importmod>>> 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.Foo object at 0x03C181F0>
12
>>>
>>> importmod>>> 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.Foo object at 0x03C181F0>
2
Bởi vì dạng
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
8 này đặt tên đối tượng trực tiếp vào bảng ký hiệu của người gọi, bất kỳ đối tượng nào đã tồn tại có cùng tên sẽ bị ghi đè
>>>
>>> importmod>>> 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.Foo object at 0x03C181F0>
3
Thậm chí có thể
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
8 mọi thứ từ một mô-đun một cách bừa bãi
>>> importmod>>> 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.Foo object at 0x03C181F0>
4
Thao tác này sẽ đặt tên của tất cả các đối tượng từ
>>> importmod>>> 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.Foo object at 0x03C181F0>
12 vào bảng ký hiệu cục bộ, ngoại trừ bất kỳ đối tượng nào bắt đầu bằng ký tự gạch dưới (
>>> importmod>>> 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.Foo object at 0x03C181F0>
28)
Ví dụ
>>>
>>> importmod>>> 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.Foo object at 0x03C181F0>
5
Điều này không nhất thiết được khuyến nghị trong mã sản xuất quy mô lớn. Hơi nguy hiểm vì bạn đang nhập tên vào bảng ký hiệu cục bộ hàng loạt. Trừ khi bạn biết rõ tất cả chúng và có thể tự tin rằng sẽ không có xung đột, nếu không bạn sẽ có cơ hội vô tình ghi đè lên một tên hiện có. Tuy nhiên, cú pháp này khá tiện dụng khi bạn chỉ loay hoay với trình thông dịch tương tác, cho mục đích thử nghiệm hoặc khám phá, bởi vì nó nhanh chóng cho phép bạn truy cập vào mọi thứ mà một mô-đun cung cấp mà không cần gõ nhiề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
<mod.Foo object at 0x03C181F0>
29
Cũng có thể
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
8 đối tượng riêng lẻ nhưng nhập chúng vào bảng ký hiệu cục bộ với các tên thay thế
>>> importmod>>> 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.Foo object at 0x03C181F0>
6
Điều này cho phép đặt tên trực tiếp vào bảng ký hiệu cục bộ nhưng tránh xung đột với các tên đã tồn tại trước đó
>>>
>>> importmod>>> 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.Foo object at 0x03C181F0>
7
>>> 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.Foo object at 0x03C181F0>
31
Bạn cũng có thể nhập toàn bộ mô-đun dưới tên thay thế
>>> importmod>>> 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.Foo object at 0x03C181F0>
8
>>>
>>> importmod>>> 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.Foo object at 0x03C181F0>
9
Nội dung mô-đun có thể được nhập từ bên trong định nghĩa hàm. Trong trường hợp đó,
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
8 không xảy ra cho đến khi hàm được gọi
>>>
importmod
0
Tuy nhiên, Python 3 không cho phép cú pháp
>>> importmod>>> 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.Foo object at 0x03C181F0>
33 bừa bãi từ bên trong một hàm
>>>
importmod
1
Cuối cùng, một câu lệnh
>>> importmod>>> 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.Foo object at 0x03C181F0>
34 với mệnh đề
>>> importmod>>> 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.Foo object at 0x03C181F0>
35 có thể được sử dụng để đề phòng những nỗ lực không thành công của
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
8
>>>
importmod
2
>>>
importmod
3Loại bỏ các quảng cáo
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
<mod.Foo object at 0x03C181F0>
37
Hàm dựng sẵn
>>> importmod>>> 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.Foo object at 0x03C181F0>
37 trả về danh sách các tên đã xác định trong một không gian tên. Không có đối số, nó tạo ra một danh sách các tên được sắp xếp theo thứ tự bảng chữ cái trong bảng ký hiệu cục bộ hiện tại
>>>
importmod
4
Lưu ý cách cuộc gọi đầu tiên tới
>>> importmod>>> 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.Foo object at 0x03C181F0>
37 ở trên liệt kê một số tên được xác định tự động và đã có trong không gian tên khi trình thông dịch bắt đầu. Khi các tên mới được xác định (
>>> importmod>>> 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.Foo object at 0x03C181F0>
40,
>>> importmod>>> 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.Foo object at 0x03C181F0>
41,
>>> importmod>>> 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.Foo object at 0x03C181F0>
42), chúng sẽ xuất hiện trong các lần gọi tiếp theo của
>>> importmod>>> 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.Foo object at 0x03C181F0>
37
Đ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
>>>
importmod
5
Khi đưa ra một đối số là tên của một mô-đun,
>>> importmod>>> 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.Foo object at 0x03C181F0>
37 liệt kê các tên được xác định trong mô-đun
>>>
importmod
6
>>>
importmod
7
Thực thi một Mô-đun dưới dạng Tập lệnh
Bất kỳ tệp
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
9 nào chứa mô-đun về cơ bản cũng là một tập lệnh Python và không có lý do gì mà nó không thể được thực thi như một
Đây lại là
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
0 như đã định nghĩa ở trên
chế độ. py
s="If Comrade Napoleon says it, it must be right."a=[100,200,300]deffoo(arg):print(f'arg = {arg}')classFoo:pass
Điều này có thể được chạy như một tập lệnh
importmod
9
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
Đâ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
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
9 được nhập dưới dạng một mô-đun, Python đặt biến dunder đặc biệt
>>> importmod>>> 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.Foo object at 0x03C181F0>
48 thành tên của mô-đun. Tuy nhiên, nếu một tệp được chạy dưới dạng tập lệnh độc lập, thì
>>> importmod>>> 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.Foo object at 0x03C181F0>
48 được đặt (một cách sáng tạo) thành chuỗi
>>> importmod>>> 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.Foo object at 0x03C181F0>
50. Sử dụng thực tế này, bạn có thể phân biệt trường hợp nào xảy ra trong thời gian chạy và thay đổi hành vi cho phù hợp
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
>>> importmod>>> 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.Foo object at 0x03C181F0>
>>> importmod>>> 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.Foo object at 0x03C181F0>
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
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
>>> importmod>>> 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.Foo object at 0x03C181F0>
54 không được thực hiện trong các lần nhập tiếp theo. (Đối với vấn đề đó, câu lệnh gán cũng vậy, nhưng khi hiển thị cuối cùng giá trị của
>>> importmod>>> 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.Foo object at 0x03C181F0>
55 cho thấy, điều đó không thành vấn đề. Một khi nhiệm vụ được thực hiện, nó dính. )
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à
>>> importmod>>> 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.Foo object at 0x03C181F0>
56 từ mô-đun
>>> importmod>>> 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.Foo object at 0x03C181F0>
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à
>>> importmod>>> 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.Foo object at 0x03C181F0>
58 chứa hai mô-đun,
>>> importmod>>> 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.Foo object at 0x03C181F0>
59 và
>>> importmod>>> 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.Foo object at 0x03C181F0>
>>> importmod>>> 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.Foo object at 0x03C181F0>
58 nằm ở vị trí có thể tìm thấy thư mục đó (tại một trong các thư mục có trong
>>> mod.s'If Comrade Napoleon says it, it must be right.'>>> mod.foo('quux')arg = quux
2), bạn có thể tham khảo hai mô-đun có ký hiệu dấu chấm (
>>> importmod>>> 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.Foo object at 0x03C181F0>
63,
>>> importmod>>> 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.Foo object at 0x03C181F0>
64) và nhập chúng bằng cú pháp mà bạn
>>> importmod>>> 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.Foo object at 0x03C181F0>
>>> importmod>>> 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.Foo object at 0x03C181F0>
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 biệt, nó không đặt bất kỳ mô-đun nào trong
>>> importmod>>> 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.Foo object at 0x03C181F0>
Để 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
Loại bỏ các quảng cáo
Khởi tạo gói
Nếu một tệp có tên
>>> importmod>>> 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.Foo object at 0x03C181F0>
66 có trong thư mục gói, nó sẽ được gọi khi gói hoặc mô-đun trong gói được nhập. Điều này có thể được sử dụng để thực thi mã khởi tạo gói, chẳng hạn như khởi tạo dữ liệu cấp gói
Ví dụ: xem xét tệp
>>> importmod>>> 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.Foo object at 0x03C181F0>
>>> importmod>>> 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.Foo object at 0x03C181F0>
58 từ ví dụ trên
Bây giờ khi gói được nhập, danh sách toàn cầu
>>> importmod>>> 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.Foo object at 0x03C181F0>
>>> importmod>>> 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.Foo object at 0x03C181F0>
66 cũng có thể được sử dụng để tự động nhập các mô-đun từ một gói. Ví dụ: trước đó bạn đã thấy rằng câu lệnh
>>> importmod>>> 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.Foo object at 0x03C181F0>
71 chỉ đặt tên
>>> importmod>>> 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.Foo object at 0x03C181F0>
58 trong bảng ký hiệu cục bộ của người gọi và không nhập bất kỳ mô-đun nào. Nhưng nếu
>>> importmod>>> 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.Foo object at 0x03C181F0>
66 trong thư mục
>>> importmod>>> 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.Foo object at 0x03C181F0>
>>> importmod>>> 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.Foo object at 0x03C181F0>
71, các mô-đun
>>> importmod>>> 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.Foo object at 0x03C181F0>
76 và
>>> importmod>>> 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.Foo object at 0x03C181F0>
>>> importmod>>> 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.Foo object at 0x03C181F0>
66 phải có trong thư mục gói khi tạo gói. Điều này đã từng đúng. Trước đây, chính sự hiện diện của
>>> importmod>>> 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.Foo object at 0x03C181F0>
66 đã báo hiệu cho Python rằng một gói đang được xác định. Tệp có thể chứa mã khởi tạo hoặc thậm chí trống, nhưng nó phải có mặt
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
>>> importmod>>> 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.Foo object at 0x03C181F0>
66 nào. Tất nhiên, nó vẫn có thể xuất hiện nếu cần khởi tạo gói. Nhưng nó không còn cần thiết
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
<mod.Foo object at 0x03C181F0>
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 xác định trong thư mục
>>> importmod>>> 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.Foo object at 0x03C181F0>
>>> importmod>>> 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.Foo object at 0x03C181F0>
33 được sử dụng cho một mô-đun, tất cả các đối tượng từ mô-đun được nhập vào bảng ký hiệu cục bộ, ngoại trừ những đối tượng có tên bắt đầu bằng dấu gạch dưới, như thường lệ
>>>
import<module_name>
4
Câu lệnh tương tự cho một gói là thế này
import<module_name>
5
Cái đó làm cái gì?
>>>
import<module_name>
6
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
>>> importmod>>> 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.Foo object at 0x03C181F0>
66 trong thư mục gói chứa danh sách có tên
>>> importmod>>> 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.Foo object at 0x03C181F0>
85, thì nó được coi là danh sách các mô-đun sẽ được nhập khi gặp câu lệnh
>>> importmod>>> 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.Foo object at 0x03C181F0>
86
Đối với ví dụ hiện tại, giả sử bạn tạo một
>>> importmod>>> 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.Foo object at 0x03C181F0>
66 trong thư mục
>>> importmod>>> 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.Foo object at 0x03C181F0>
58 như thế này
pkg/__init__. py
import<module_name>
7
Bây giờ
>>> importmod>>> 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.Foo object at 0x03C181F0>
89 nhập cả bốn mô-đun
>>>
import<module_name>
8
Sử dụng
>>> importmod>>> 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.Foo object at 0x03C181F0>
33 vẫn không được coi là hình thức tuyệt vời, nhiều hơn cho các gói hơn là cho các mô-đun. Nhưng cơ sở này ít nhất cung cấp cho người tạo gói một số quyền kiểm soát đối với những gì xảy ra khi ____12_______33 được chỉ định. (Trên thực tế, nó cung cấp khả năng không cho phép hoàn toàn, đơn giản bằng cách từ chối xác định
>>> importmod>>> 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.Foo object at 0x03C181F0>
85. Như bạn đã thấy, hành vi mặc định cho các gói là không nhập gì cả. )
Nhân tiện,
>>> importmod>>> 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.Foo object at 0x03C181F0>
85 cũng có thể được định nghĩa trong một mô-đun và phục vụ cùng một mục đích. để kiểm soát những gì được nhập khẩu với
>>> importmod>>> 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.Foo object at 0x03C181F0>
33. Ví dụ, sửa đổi
>>> importmod>>> 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.Foo object at 0x03C181F0>
59 như sau
pkg/mod1. py
import<module_name>
9
Bây giờ, một câu lệnh
>>> importmod>>> 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.Foo object at 0x03C181F0>
33 từ
>>> importmod>>> 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.Foo object at 0x03C181F0>
63 sẽ chỉ nhập những gì có trong
>>> importmod>>> 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.Foo object at 0x03C181F0>
85
>>>
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
0
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
4 (hàm) hiện được xác định trong không gian tên cục bộ, nhưng
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
5 (lớp) thì không, vì lớp sau không có trong
>>> importmod>>> 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.Foo object at 0x03C181F0>
85
Tóm lại,
>>> importmod>>> 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.Foo object at 0x03C181F0>
85 được sử dụng bởi cả gói và mô-đun để kiểm soát những gì được nhập khi ____12_______33 được chỉ định. Nhưng hành vi mặc định khác
Đối với một gói, khi
>>> importmod>>> 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.Foo object at 0x03C181F0>
85 không được xác định, thì
>>> importmod>>> 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.Foo object at 0x03C181F0>
33 không nhập bất cứ thứ gì
Đối với một mô-đun, khi
>>> importmod>>> 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.Foo object at 0x03C181F0>
85 không được xác định, thì ______12_______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)
Loại bỏ các quảng cáo
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 (
>>> importmod>>> 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.Foo object at 0x03C181F0>
59,
>>> importmod>>> 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.Foo object at 0x03C181F0>
60,
importmod
10 và
importmod
11) được định nghĩa như trước đây. Nhưng bây giờ, thay vì gộp chung vào thư mục
>>> importmod>>> 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.Foo object at 0x03C181F0>
58, chúng được chia thành hai thư mục gói con,
importmod
13 và
importmod
14
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ụ
>>>
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
1
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
>>> sNameError: name 's' is not defined>>> foo('quux')NameError: name 'foo' is not defined
4 (được xác định trong mô-đun
>>> importmod>>> 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.Foo object at 0x03C181F0>
76) từ bên trong mô-đun
importmod
17. Bạn có thể sử dụng nhập khẩu tuyệt đối
pkg/sub__pkg2/mod3. py
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
2
>>>
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
3
Hoặc bạn có thể sử dụng nhập tương đối, trong đó
importmod
18 đề cập đến gói tăng một cấp. Từ bên trong
importmod
10, nằm trong gói con
importmod
14,
importmod
18 đánh giá gói mẹ (
>>> importmod>>> 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.Foo object at 0x03C181F0>
58) và
importmod
23 đánh giá thành gói con
importmod
13 của gói mẹ
pkg/sub__pkg2/mod3. py
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
4
>>>
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
5
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
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
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
>>> importmod>>> mod<module 'mod' from 'C:\\Users\\john\\Documents\\Python\\doc\\mod.py'>
8
hướng dẫn Python. mô-đun
Python hạnh phúc
Đánh dấu là đã hoàn thành
Xem ngay Hướng dẫn này có một khóa học video liên quan do nhóm Real Python tạo. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn. Các mô-đun và gói Python. Giới thiệu
🐍 Thủ thuật Python 💌
Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python
Gửi cho tôi thủ thuật Python »
Giới thiệu về John Sturtz
John là một Pythonista cuồng nhiệt và là thành viên của nhóm hướng dẫn Real Python
» Thông tin thêm về John
Mỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là
Đan
Joanna
Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia
Nâng cao kỹ năng Python của bạn »
Chuyên gia Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia
Nâng cao kỹ năng Python của bạn »
Bạn nghĩ sao?
Đánh giá bài viết này
Tweet Chia sẻ Chia sẻ Email
Bài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?
Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi