programming python

Thư viện nhâm nhi python

Mô-đun và gói là những cấp độ quản lý mã cao hơn trong Python. Mô-đun cho phép lưu trữ hàm [và mã khác] trên các tệp riêng rẽ để sau đó tái sử dụng trong các tệp và dự án khác. Gói cho phép nhóm các mô-đun lại với nhau. Sử dụng mô-đun và gói giúp bạn dễ dàng quản lý mã trong các chương trình lớn cũng như tái sử dụng mã về sau

ĐỘI DUNG CỦA BẢN DỊCH Ẩn

1. Ví dụ sử dụng mô-đun trong Python

2. Mô-đun trong Python

3. Sử dụng mô-đun với nhập …

4. Sử dụng mô-đun với from … import …

5. Mô-đun thực thi

6. Vấn đề đường dẫn khi sử dụng mô-đun

7. Sử dụng gói trong Python

8. Kết luận

Ví dụ sử dụng module trong Python

Hãy bắt đầu với một ví dụ minh họa. Tạo hai tệp 

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
8 và 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
9 trong cùng một thư mục và viết mã như sau

print['--- start of my_math ---']
PI = 3.14159
E = 2.71828
message = 'My math module'
def sum[start, *numbers]:
	'''Calculate the sum of unlimited number
	Params:
		start:int/float, the start sum
		*numbers:int/float, the numbers to sum up
	Return: int/float
	'''
	for x in numbers:
		start += x
	return start
def sum_range[start, stop, step=1]:
	'''	Calculate the sum of intergers
	Params:
		start:int, start range number
		stop:int, stop range number
		step:int, the step between value
	Returns: int
	'''
	sum = 0
	for i in range[start, stop, step]:
		sum += i
	return sum
def fact[n]:
	'''Calculate the factorial of n
	Params:
		n:int
	Return: int
	'''
	p = 1
	for i in range[1, n + 1]:
		p *= i
	return p
print['--- start of my_math ---']
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]

You must run program from file main. py. Kết quả thu được như sau

File 

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
8 là một file script Python hoàn toàn bình thường. Trong tệp này định nghĩa một số hàm tính toán [
import my_math
1, 
import my_math
2, 
import my_math
3] và một số biến [
import my_math
4, 
import my_math
5, 
import my_math
6]. Điểm khác biệt của tệp này là chỉ chứa định nghĩa hàm nhưng không sử dụng [gọi] hàm

Trong tệp 

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
9 chúng ta sử dụng các hàm đã xây dựng từ 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
8

To command 

import my_math
9 at the first file. Đây là lệnh yêu cầu Python tải nội dung của tệp 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
8 khi chạy tập lệnh tệp 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
9

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
62 và 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
63 là hai mô-đun trong Python

Mô-đun trong Python

Trong Python, bất kỳ file script [file có đuôi py] đều được gọi là module. Khi bạn tạo một mã tệp Python mới, bạn đang tạo một mô-đun. Như vậy, ngay từ những bài học đầu tiên bạn đã xây dựng mô-đun Python

Tên mô-đun là tên tệp [bỏ phần mở rộng py]. Trong ví dụ ở phần trên, Mô-đun 

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
62 viết trong tệp 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
8. Module 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
63 viết trong file 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
9

Mỗi mô-đun đều có thể được tải xuống và thực thi bởi trình thông dịch Python. Như ở trên, bạn có thể chạy module my_math và main riêng rẽ vì chúng đều là mã tệp Python hợp lệ

Tuy nhiên, nếu bạn chạy module my_math thì sẽ không ra kết quả gì vì trong module này chúng ta chỉ định nghĩa các hàm và biến chứ không phải chúng ta không sử dụng. Đây là điểm khác biệt giữa my_math và main. trong my_math chỉ chứa khai báo [hàm/biến], trong chính chứa lời gọi

Như vậy, cách thức xây dựng và cách sử dụng cho các mô-đun khác nhau. Có những mô-đun được xây dựng với vai trò cung cấp thư viện hàm cho mô-đun khác sử dụng. Có những mô-đun sử dụng chức năng định nghĩa trong các mô-đun khác

Để sử dụng hàm/biến/định nghĩa dữ liệu trong tệp/mô-đun khác, Python sử dụng lệnh nhập. Có hai kiểu lệnh nhập khẩu khác nhau

  1. import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
    68
  2. import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
    69

Use module with import …

Trong ví dụ minh họa chúng ta đã sử dụng lối viết này

import my_math

Cách viết này sẽ tải xuống toàn bộ mô-đun my_math, gần giống như việc sao chép nội dung của my_math. py set into the position of command 

import my_math
9 and run program. Điều này có nghĩa là tất cả các lệnh trong mô-đun đều được thực hiện khi nhập

Bạn có thể thấy điều này khi cặp lệnh print[] viết ở đầu và cuối mô-đun my_math đều được thực hiện

Cách này sẽ chỉ tải mô-đun khi nhập lệnh lần đầu tiên. Khi gặp lệnh nhập lần thứ hai, Python sẽ không tải mô-đun nữa. Bạn có thể thấy rõ điều này khi cặp lệnh print[] ở đầu và cuối mô-đun my_math chỉ được gọi một lần duy nhất trước khi bắt đầu mô-đun chính mặc dù chúng ta viết lệnh 

import my_math
9 hai lần

Please for the way we call function and use variable [được khai báo trong module my_math]

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
6

Tức là, thay vì viết trực tiếp tên hàm/biến, bạn phải cung cấp thêm tên mô-đun my_math. Cấu hình chung cấu trúc để sử dụng một hàm/biến trong mô-đun khác là 

print['--- start of my_math ---']
PI = 3.14159
E = 2.71828
message = 'My math module'
def sum[start, *numbers]:
	'''Calculate the sum of unlimited number
	Params:
		start:int/float, the start sum
		*numbers:int/float, the numbers to sum up
	Return: int/float
	'''
	for x in numbers:
		start += x
	return start
def sum_range[start, stop, step=1]:
	'''	Calculate the sum of intergers
	Params:
		start:int, start range number
		stop:int, stop range number
		step:int, the step between value
	Returns: int
	'''
	sum = 0
	for i in range[start, stop, step]:
		sum += i
	return sum
def fact[n]:
	'''Calculate the factorial of n
	Params:
		n:int
	Return: int
	'''
	p = 1
	for i in range[1, n + 1]:
		p *= i
	return p
print['--- start of my_math ---']
82 và 
print['--- start of my_math ---']
PI = 3.14159
E = 2.71828
message = 'My math module'
def sum[start, *numbers]:
	'''Calculate the sum of unlimited number
	Params:
		start:int/float, the start sum
		*numbers:int/float, the numbers to sum up
	Return: int/float
	'''
	for x in numbers:
		start += x
	return start
def sum_range[start, stop, step=1]:
	'''	Calculate the sum of intergers
	Params:
		start:int, start range number
		stop:int, stop range number
		step:int, the step between value
	Returns: int
	'''
	sum = 0
	for i in range[start, stop, step]:
		sum += i
	return sum
def fact[n]:
	'''Calculate the factorial of n
	Params:
		n:int
	Return: int
	'''
	p = 1
	for i in range[1, n + 1]:
		p *= i
	return p
print['--- start of my_math ---']
83

You can use alias in command as after

print['--- start of my_math ---']
PI = 3.14159
E = 2.71828
message = 'My math module'
def sum[start, *numbers]:
	'''Calculate the sum of unlimited number
	Params:
		start:int/float, the start sum
		*numbers:int/float, the numbers to sum up
	Return: int/float
	'''
	for x in numbers:
		start += x
	return start
def sum_range[start, stop, step=1]:
	'''	Calculate the sum of intergers
	Params:
		start:int, start range number
		stop:int, stop range number
		step:int, the step between value
	Returns: int
	'''
	sum = 0
	for i in range[start, stop, step]:
		sum += i
	return sum
def fact[n]:
	'''Calculate the factorial of n
	Params:
		n:int
	Return: int
	'''
	p = 1
	for i in range[1, n + 1]:
		p *= i
	return p
print['--- start of my_math ---']
8

Tên 

print['--- start of my_math ---']
PI = 3.14159
E = 2.71828
message = 'My math module'
def sum[start, *numbers]:
	'''Calculate the sum of unlimited number
	Params:
		start:int/float, the start sum
		*numbers:int/float, the numbers to sum up
	Return: int/float
	'''
	for x in numbers:
		start += x
	return start
def sum_range[start, stop, step=1]:
	'''	Calculate the sum of intergers
	Params:
		start:int, start range number
		stop:int, stop range number
		step:int, the step between value
	Returns: int
	'''
	sum = 0
	for i in range[start, stop, step]:
		sum += i
	return sum
def fact[n]:
	'''Calculate the factorial of n
	Params:
		n:int
	Return: int
	'''
	p = 1
	for i in range[1, n + 1]:
		p *= i
	return p
print['--- start of my_math ---']
84 trong lệnh trên được gọi là bí danh [tên giả] của 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
62. Khi điều này thay vì sử dụng tên mô-đun my_math, bạn có thể sử dụng bí danh mm như sau

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
3

Nghĩa là bạn có thể sử dụng bí danh thay cho tên mô-đun. Bạn có thể đồng thời sử dụng cả tên mô-đun và bí danh

Bí danh rất tiện lợi khi tên mô-đun quá dài hoặc tên mô-đun trùng lặp với một hàm/biến có sẵn của Python

Use module with from … import …

Giờ hãy xóa [hoặc nhận xét] toàn bộ mã của mã chính. py và viết lại mã mới như sau

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
4

Ở đây chúng ta gặp cách sử dụng thứ hai của nhập khẩu. 

print['--- start of my_math ---']
PI = 3.14159
E = 2.71828
message = 'My math module'
def sum[start, *numbers]:
	'''Calculate the sum of unlimited number
	Params:
		start:int/float, the start sum
		*numbers:int/float, the numbers to sum up
	Return: int/float
	'''
	for x in numbers:
		start += x
	return start
def sum_range[start, stop, step=1]:
	'''	Calculate the sum of intergers
	Params:
		start:int, start range number
		stop:int, stop range number
		step:int, the step between value
	Returns: int
	'''
	sum = 0
	for i in range[start, stop, step]:
		sum += i
	return sum
def fact[n]:
	'''Calculate the factorial of n
	Params:
		n:int
	Return: int
	'''
	p = 1
	for i in range[1, n + 1]:
		p *= i
	return p
print['--- start of my_math ---']
86

Khi sử dụng cấu trúc từ. nhập bạn có thể thấy rằng Python vẫn nhập toàn bộ mã của mô-đun my_math [như trường hợp sử dụng 

import my_math
9]. Điều này có thể thực hiện thông qua hai lệnh print[] ở đầu và cuối mô-đun my_math đều được thực hiện ở vị trí gọi từ. nhập khẩu

Tuy nhiên, giờ đây bạn không thể sử dụng được tất cả các hàm/biến số của mô-đun my_math như trước đây nữa. Giờ bạn chỉ có thể sử dụng hàm 

print['--- start of my_math ---']
PI = 3.14159
E = 2.71828
message = 'My math module'
def sum[start, *numbers]:
	'''Calculate the sum of unlimited number
	Params:
		start:int/float, the start sum
		*numbers:int/float, the numbers to sum up
	Return: int/float
	'''
	for x in numbers:
		start += x
	return start
def sum_range[start, stop, step=1]:
	'''	Calculate the sum of intergers
	Params:
		start:int, start range number
		stop:int, stop range number
		step:int, the step between value
	Returns: int
	'''
	sum = 0
	for i in range[start, stop, step]:
		sum += i
	return sum
def fact[n]:
	'''Calculate the factorial of n
	Params:
		n:int
	Return: int
	'''
	p = 1
	for i in range[1, n + 1]:
		p *= i
	return p
print['--- start of my_math ---']
88, 
print['--- start of my_math ---']
PI = 3.14159
E = 2.71828
message = 'My math module'
def sum[start, *numbers]:
	'''Calculate the sum of unlimited number
	Params:
		start:int/float, the start sum
		*numbers:int/float, the numbers to sum up
	Return: int/float
	'''
	for x in numbers:
		start += x
	return start
def sum_range[start, stop, step=1]:
	'''	Calculate the sum of intergers
	Params:
		start:int, start range number
		stop:int, stop range number
		step:int, the step between value
	Returns: int
	'''
	sum = 0
	for i in range[start, stop, step]:
		sum += i
	return sum
def fact[n]:
	'''Calculate the factorial of n
	Params:
		n:int
	Return: int
	'''
	p = 1
	for i in range[1, n + 1]:
		p *= i
	return p
print['--- start of my_math ---']
89, và biến 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
30

Điều đặc biệt là bạn có thể sử dụng tên rút gọn của các đối tượng này [không cần đặt tên mô-đun], giống như khi các đối tượng này được khai báo trực tiếp trong mô-đun chính

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
0

Bạn cũng có thể chỉ định bí danh cho từng tên gọi trong lệnh từ. nhập khẩu như sau

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
1

Ở đây khi nhập chúng ta chỉ định alias sr cho hàm sum_range[], f cho hàm fact[], msg cho biến thông báo. Trong mã sau đó chúng ta có thể sử dụng bí danh thay cho tên thật

Lưu ý, nếu bạn đã đặt bí danh thì không thể sử dụng tên thật của đối tượng được nữa. Tức là không thể đồng thời sử dụng bí danh và tên thật

Bạn cũng có thể sử dụng cách nhập như sau

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
2

Tuy nhiên, đây là cách thức không được khuyến khích. Nó dễ dàng làm rối loạn không gian tên của mô-đun hiện tại nếu có quá nhiều tên gọi được nhập

Go to the general output effect, both way import near as are compatible nhau. Sự khác biệt chỉ nằm ở cách sử dụng các đối tượng từ mô-đun.
______331 tiện lợi hơn nếu bạn chỉ có nhu cầu sử dụng một vài đối tượng từ mô-đun. Nó không làm rối không gian tên bằng các chức năng không được sử dụng.
Nếu cần sử dụng rất nhiều hàm từ mô-đun, bạn nên sử dụng nhập [kết hợp với bí danh]. Nó giúp bạn phân biệt chức năng của mô-đun.

Thực hiện mô-đun thi

Khi xây dựng một mô-đun, bạn có thể dự đoán tình trạng phòng hai

  1. Mô-đun đó được thực thi trực tiếp [chạy mô-đun đó ở chế độ kịch bản]
  2. Mô-đun được nhập vào một mô-đun khác, tạm gọi là thực thi gián tiếp [khi được nhập, toàn bộ mã của mô-đun được thực thi 1 lần]

Mỗi mô-đun có một thuộc tính đặc biệt tên là 

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
32. Lưu ý có hai dấu _ trước và sau tên. You can try in a command 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
33

Khi một mô-đun được thực thi trực tiếp, 

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
32 sẽ được gán giá trị cho 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
35. Nếu khi thực hiện một mô-đun mà 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
36‘ thì đây là mô-đun chủ của chương trình

Khi một mô-đun được thực thi gián tiếp, thì 

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
32 của nó sẽ có giá trị là tên mô-đun [cũng là tên tệp bỏ qua phần mở rộng py]

Với đặc thù trên, khi xây dựng mô-đun trong Python cần chạy ở cả hai kiểu [trực tiếp và gián tiếp] người ta thường sử dụng mẫu sau đây

  1. Mỗi mô-đun sẽ có một hàm 
    import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
    38 chứa các lệnh cần thực thi theo kiểu trực tiếp;
  2. Check tra if 
    import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
    39 thì thực thi main[]
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
0

Khi chạy gián tiếp thông qua nhập khẩu 

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
32 sẽ không thể có giá trị của 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
41, vì logic của 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
38 sẽ không thực thi

Khi một mô-đun được chạy gián tiếp thông qua quá trình nhập, Python cũng thực hiện lưu bản dịch bytecode tạm thời của nó trong thư mục 

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
43. Thư mục 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
43 nằm trong cùng thư mục với mô-đun được nhập. Ví dụ, với mô-đun 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
62, khi được nhập, Python sẽ tạo ra tệp 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
46 [nếu bạn sử dụng Python 3. số 8]. Nếu bạn có nhiều phiên bản Python khác nhau, khi chạy với bất kỳ phiên bản nào, tệp pyc sẽ có tên ứng dụng tương ứng

Nhắc lại. khi chạy một script, Python sẽ dịch nó thành bytecode trung gian. Chương trình máy ảo của Python sẽ tiếp tục chuyển mã bytecode thành mã máy để thực thi trên từng hệ điều hành

Tệp bytecode của Python có phần mở rộng là pyc

Khi nhập một mô-đun xảy ra quá trình dịch bytecode như vậy. Tuy nhiên, Python sẽ lưu lại tệp pyc để lần sau không cần dịch lại. Việc lưu trữ tệp pyc giúp giảm thời gian tải xuống một chương trình

Lưu ý, khi trực tiếp thực hiện một mô-đun Python sẽ không lưu lại mã byte của tệp

Tệp bytecode không thực thi nhanh hơn. Nó chỉ giảm thời gian tải ứng dụng

Vì lý do này, khi xây dựng chương trình bằng Python, bạn nên tận hưởng việc xây dựng và nhập mô-đun, thay vì mã trực tiếp trong một mô-đun chính lớn. Toàn bộ mã nên đưa về các mô-đun và để mô-đun chính đơn giản nhất có thể

Đường dẫn vấn đề khi sử dụng mô-đun

Bạn có thể thấy khi nhập mô-đun, bạn không chỉ định đường dẫn đến tệp script. Python thực hiện việc tìm mô-đun tệp tìm kiếm tự động theo các thư mục lưu trong biến sys. con đường

biến hệ thống. đường dẫn là một danh sách lưu các đường dẫn đã được đăng ký trong Python. You can see content of sys. path as after

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
1

Bạn có thể chỉ định đường dẫn ban đầu chính là thư mục làm việc [thư mục hiện hành] nơi bạn đặt mô-đun tệp chính. Ví dụ, nếu bạn chạy module main. py and in main. py has command import my_math, Python before hết will find my_math search. py trong thư mục chứa main. py

Nếu không tìm thấy tệp tương ứng, Python sẽ tìm lần nữa trong các thư mục còn lại

Để giải quyết một vấn đề khác. Giả sử bạn có mô-đun mysql nằm trong tệp 

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
47 nằm trong thư mục con 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
48 của thư mục hiện hành [tức là đường dẫn tương đối tới tệp là 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
49]

Để nhập mô-đun mysql, bạn cần viết như sau. 

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
00. Tức là bạn cần chỉ định cấu trúc đường dẫn tương đối tới mô-đun. Sự khác biệt ở chỗ các phần của đường dẫn được phân tách bằng dấu chấm. Python sẽ tự động ghép đường dẫn này với các đường dẫn được lưu trong 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
01

Nếu trong trường hợp các mô-đun tệp của bạn nằm ở một nơi khác [không nằm trong danh sách hệ thống. đường dẫn mặc định], bạn phải có đường dẫn chỉ định để Python có thể tìm thấy. Cách đơn giản nhất như sau

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
2

Logic ở đây rất đơn giản. làm hệ thống. đường dẫn chỉ là một danh sách, bạn có thể tự thêm một đường dẫn mới vào sys. con đường. Khi đó Python sẽ tìm kiếm cả trong đường dẫn bạn thêm vào

Ví dụ

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
3

Sử dụng package trong Python

Trong Python, một số mô-đun trong cùng thư mục [và thư mục con] có thể kết hợp lại để tạo ra một gói. Gói giúp đơn giản hóa hơn nữa việc sử dụng nhiều mô-đun có liên quan

Hãy cùng thực hiện ví dụ sau

Create my_package directory. Trong thư mục này, tạo hai tệp module1. py và module2. py with code as after

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
4
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
5

Nếu dừng lại ở đây, bạn sẽ có hai mô-đun riêng rẽ. Khi sử dụng bạn cần nhập từng mô-đun

Giờ hãy tạo tệp __init__. py in my_package directory. Lưu ý có hai ký tự _ ở trước và sau init. Viết mã như sau cho __init__. py

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
6

Đây là hai lệnh nhập thông thường mà bạn đã học ở phần trên. Bạn có thể sử dụng kiểu nhập khẩu nào cũng được. Tuy nhiên, cần lưu ý về cách viết tên mô-đun. 

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
02. Bạn cần chỉ định tên thư mục, nếu không Python sẽ không tìm thấy mô-đun tương ứng

Tên tệp __init__. py có ý nghĩa đặc biệt trong Python. Nếu Python nhìn thấy bất kỳ thư mục nào có tệp có tên gọi là __init__. py, nó sẽ tự động coi thư mục này là một gói, chứ không còn là thư mục bình thường nữa

Bên ngoài thư mục gói hãy tạo mô-đun chính. py and write code as after

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
7

Bạn có thể để ý thấy ngay rằng lệnh nhập giờ không hoạt động với từng mô-đun nữa mà là với tên thư mục my_package

Tất cả các thư mục chứa tệp __init__. py sẽ trở thành một gói. Tên thư mục trở thành tên gói và có thể sử dụng cùng lệnh nhập hoặc từ/nhập

Khi nhập một gói, bạn sẽ đồng thời nhập tất cả các mô-đun của nó [được chỉ định trong __init__. py]

Nếu sử dụng lệnh 

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
03, bạn truy cập vào các hàm của từng mô-đun qua cú pháp 
import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
04

Nếu sử dụng từ 

import my_math
print[my_math.message]
sum = my_math.sum[0, 1, 2, 3, 4]
sum_range = my_math.sum_range[1, 10]
fact = my_math.fact[3]
print['sum = ', sum]
print['sum_range = ', sum_range]
print['fact = ', fact]
print['Pi = ', my_math.PI]
print['e = ', my_math.E]
05, bạn có thể sử dụng tên rút gọn của hàm như bình thường

Lưu ý. trong __init__. py và trong gói sử dụng mô-đun nên sử dụng cùng một cách nhập. Ví dụ, cùng sử dụng nhập hoặc cùng sử dụng từ. nhập khẩu

Bài Viết Liên Quan

Excel định dạng có điều kiện các ô được mã hóa cứng
An sinh xã hội sẽ được tăng mạnh vào năm 2023?
Tại sao mã HTML của tôi hiển thị dưới dạng văn bản
Làm cách nào để kích hoạt phiên bản php đã chọn trong whm?
Làm cách nào để xóa hai phần tử cuối cùng của một mảng trong PHP?
Tạo kiểu đối tượng thành chuỗi css
Chuỗi chuỗi python
Một thùng sơn dulux bằng bao nhiêu kg
Làm cách nào để kết nối Python với MySQL lớp 12?
Chọn cơ sở dữ liệu mysql php
Lịch sách Lingen Verlag 2023
Le Mans 2023 drivers
Đọc và ghi tệp json trong html
RX 500h F Sport Performance 2023
Ví dụ về kế thừa trong Python
Phạm vi khối python
Giao dịch mysql hoạt động như thế nào?
Dự đoán rồng Shio năm 2023
Tôi có thể xây dựng một trang web bằng html không?
{} làm gì trong python?

Toplist mới

#1
Top 6 bản thân em phải làm gì để phòng chống hiv/aids 2023
6 tháng trước
#2
Top 7 số 20 gồm 2 và 0 đúng hay sai 2023
6 tháng trước
#3
Top 7 địa lý lớp 6 bài 19: lớp đất và các nhân tố hình thành đất một số nhóm đất điển hình trang 178 2023
6 tháng trước
#4
Top 7 h thực hiện chủ trương đường lối chính sách của đảng pháp luật của nhà nước 2023
6 tháng trước
#5
Top 6 on tập tiếng việt lớp 7 học kĩ 2 violet 2023
6 tháng trước
#6
Top 7 trung du và miền núi bắc bộ có thế mạnh nổi bật về luyện kim đen 2023
6 tháng trước
#7
Top 8 mơ thấy có người to tình với mình 2023
6 tháng trước
#8
Top 6 nước yến cao cấp yến sào thiên hoàng 2023
6 tháng trước
#9
Top 7 ví dụ về quyết định hành chính nhà nước 2023
6 tháng trước

Bài mới nhất

Phương pháp học tập tích cực là gì năm 2024
Hồng yến khác yến trắng như thế nào năm 2024
Thị trường thanh toán trực tuyến việt nam năm 2024
Once in a while là gì năm 2024
U nang tử cung là gì năm 2024
Làm sao để làm inox nhanh bị oxi hóa năm 2024
Đường huyết lúc đói là gì năm 2024
Bánh tráng thịt heo đà nẵng quán nào ngon năm 2024
Cách dụng cốc nguyệt san là gì năm 2024
Lỗi font chữ trong word kí tự lạ năm 2024

Chủ Đề

Hỏi Đáp Mẹo Hay Toplist Là gì Địa Điểm Hay programming Học Tốt mẹo hay Công Nghệ Nghĩa của từ Khỏe Đẹp Bao nhiêu đánh giá Top List bao nhieu bao nhiêu hướng dẫn So Sánh Tiếng anh Bài tập So sánh Xây Đựng Sản phẩm tốt Ngôn ngữ Món Ngon Bài Tập Ở đâu Thế nào Tại sao Hướng dẫn Máy tính Dịch Bao lâu Đại học Khoa Học Vì sao