Câu trả lời của Martijen có ý nghĩa, nhưng nó đã thiếu một thứ gì đó quan trọng có vẻ rõ ràng đối với người khác nhưng rất khó để tôi tìm ra.
Trong phiên bản mà bạn sử dụng Argparse, bạn cần phải có dòng này trong thân chính.
args = parser.parse_args[args]
Thông thường khi bạn đang sử dụng argparse chỉ trong một tập lệnh bạn chỉ viết
args = parser.parse_args[]
và parse_args tìm các đối số từ dòng lệnh. Nhưng trong trường hợp này, hàm chính không có quyền truy cập vào các đối số dòng lệnh, vì vậy bạn phải nói với Argparse các đối số là gì.
Đây là một ví dụ
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
Giả sử bạn đã đặt tên cho mytest.py để chạy nó, bạn có thể thực hiện bất kỳ thứ nào trong số này từ dòng lệnh
python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
mà trả về tương ứng
X center: 8.0
Y center: 4
hoặc
X center: 8.0
Y center: 2.0
hoặc
X center: 2
Y center: 4
Hoặc nếu bạn muốn chạy từ một tập lệnh Python khác, bạn có thể làm
import mytest
mytest.main[["-x","7","-y","6"]]
mà trở lại
X center: 7.0
Y center: 6.0
Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Xác định các chức năng chính trong Python This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Defining Main Functions in Python
Nhiều ngôn ngữ lập trình có một chức năng đặc biệt được tự động thực hiện khi một hệ điều hành bắt đầu chạy một chương trình. Hàm này thường được gọi là
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 và phải có một loại trả về cụ thể và các đối số theo tiêu chuẩn ngôn ngữ. Mặt khác, trình thông dịch Python thực thi các tập lệnh bắt đầu từ đầu tệp và không có chức năng cụ thể nào mà Python tự động thực thi.Tuy nhiên, có một điểm bắt đầu được xác định để thực hiện một chương trình là hữu ích để hiểu cách thức hoạt động của một chương trình. Các lập trình viên Python đã đưa ra một số quy ước để xác định điểm xuất phát này.
Đến cuối bài viết này, bạn sẽ hiểu:
- Biến
6 đặc biệt là gì và Python định nghĩa nó như thế nàoimport argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
- Tại sao bạn muốn sử dụng
5 trong Pythonimport argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
- Có những quy ước nào để xác định
5 trong Pythonimport argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
- Thực hành tốt nhất là gì cho mã nào để đặt vào
5 của bạnimport argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
Một Python chính cơ bản []
Trong một số tập lệnh Python, bạn có thể thấy một định nghĩa hàm và một câu lệnh có điều kiện trông giống như ví dụ dưới đây:
def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
Trong mã này, có một hàm gọi là
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 in cụm từ python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
1 khi trình thông dịch Python thực thi nó. Ngoài ra còn có một câu lệnh có điều kiện [hoặc python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
2] kiểm tra giá trị của import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 và so sánh nó với chuỗi python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
4. Khi câu lệnh python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
2 đánh giá thành python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
6, trình thông dịch Python thực thi import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5. Bạn có thể đọc thêm về các tuyên bố có điều kiện trong các tuyên bố có điều kiện trong Python.Mẫu mã này khá phổ biến trong các tệp Python mà bạn muốn được thực thi dưới dạng tập lệnh và được nhập trong một mô -đun khác. Để giúp hiểu mã này sẽ thực thi như thế nào, trước tiên bạn nên hiểu cách trình thông dịch Python đặt
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 tùy thuộc vào cách thực hiện mã.executed as a script and imported in another module. To help understand how this code will execute,
you should first understand how the Python interpreter sets import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 depending on how the code is being executed.Chế độ thực thi trong Python
Có hai cách chính mà bạn có thể hướng dẫn trình thông dịch Python thực thi hoặc sử dụng mã:
- Bạn có thể thực thi tệp Python dưới dạng tập lệnh bằng dòng lệnh.script using the command line.
- Bạn có thể nhập mã từ một tệp Python vào một tệp khác hoặc vào trình thông dịch tương tác.import the code from one Python file into another file or into the interactive interpreter.
Bạn có thể đọc nhiều hơn về các phương pháp này trong cách chạy các kịch bản Python của bạn. Bất kể cách chạy mã của bạn mà bạn sử dụng, Python định nghĩa một biến đặc biệt có tên
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 có chứa một chuỗi có giá trị phụ thuộc vào cách sử dụng mã.
Chúng tôi sẽ sử dụng tệp ví dụ này, được lưu dưới dạng
X center: 8.0
Y center: 4
0, để khám phá cách hành vi của mã thay đổi tùy thuộc vào ngữ cảnh:args = parser.parse_args[]
0Trong tệp này, có ba cuộc gọi đến
X center: 8.0
Y center: 4
1 được xác định. Hai bản in đầu tiên một số cụm từ giới thiệu. X center: 8.0
Y center: 4
1 thứ ba trước tiên sẽ in cụm từ X center: 8.0
Y center: 4
3, và sau đó nó sẽ in biểu diễn của biến import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 bằng cách sử dụng Python, tích hợp X center: 8.0
Y center: 4
5.Trong Python,
X center: 8.0
Y center: 4
5 hiển thị biểu diễn có thể in của một đối tượng. Ví dụ này sử dụng X center: 8.0
Y center: 4
5 để nhấn mạnh rằng giá trị của import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 là một chuỗi. Bạn có thể đọc thêm về X center: 8.0
Y center: 4
5 trong tài liệu Python.Bạn sẽ thấy tệp từ, mô -đun và tập lệnh được sử dụng trong suốt bài viết này. Trên thực tế, có nhiều sự khác biệt giữa họ. Tuy nhiên, có sự khác biệt nhỏ về ý nghĩa nhấn mạnh mục đích của một đoạn mã:file, module, and script used throughout this article. Practically, there isn’t much difference between them. However, there are slight differences in meaning that emphasize the purpose of a piece of code:
Tệp: Thông thường, tệp Python là bất kỳ tệp nào chứa mã. Hầu hết các tệp Python có phần mở rộng
0. Typically, a Python file is any file that contains code. Most Python files have the extensionX center: 8.0 Y center: 2.0
0.X center: 8.0 Y center: 2.0
Tập lệnh: Tập lệnh Python là một tệp mà bạn dự định thực thi từ dòng lệnh để hoàn thành một tác vụ. A Python script is a file that you intend to execute from the command line to accomplish a task.
Mô -đun: Mô -đun Python là một tệp mà bạn dự định nhập từ trong một mô -đun khác hoặc tập lệnh hoặc từ trình thông dịch tương tác. Bạn có thể đọc thêm về các mô -đun trong các mô -đun và gói Python - Giới thiệu. A Python module is a file that you intend to import from within another module or a script, or from the interactive interpreter. You can read more about modules in Python Modules and Packages – An Introduction.
Sự khác biệt này cũng được thảo luận trong cách chạy các kịch bản Python của bạn.
Thực thi từ dòng lệnh
Trong cách tiếp cận này, bạn muốn thực hiện tập lệnh Python của mình từ dòng lệnh.
Khi bạn thực thi một tập lệnh, bạn sẽ không thể xác định tương tác mã mà trình thông dịch Python đang thực thi. Các chi tiết về cách bạn có thể thực hiện Python từ dòng lệnh của mình không quan trọng cho mục đích của bài viết này, nhưng bạn có thể mở rộng hộp bên dưới để đọc thêm về sự khác biệt giữa dòng lệnh trên Windows, Linux và MacOS.
Cách bạn bảo máy tính thực thi mã từ dòng lệnh hơi khác nhau tùy thuộc vào hệ điều hành của bạn.
Trên Linux và MacOS, dòng lệnh thường trông giống như ví dụ dưới đây:
args = parser.parse_args[]
1Phần trước dấu hiệu đô la [
X center: 8.0
Y center: 2.0
1] có thể trông khác nhau, tùy thuộc vào tên người dùng của bạn và tên máy tính của bạn. Các lệnh mà bạn gõ sẽ theo đuổi X center: 8.0
Y center: 2.0
1. Trên Linux hoặc MacOS, tên của Python 3 thực thi là X center: 8.0
Y center: 2.0
3, vì vậy bạn nên chạy các tập lệnh Python bằng cách nhập X center: 8.0
Y center: 2.0
4 sau X center: 8.0
Y center: 2.0
1.Trên Windows, lời nhắc lệnh thường trông giống như ví dụ dưới đây:
args = parser.parse_args[]
2Phần trước
X center: 8.0
Y center: 2.0
6 có thể trông khác nhau, tùy thuộc vào tên người dùng của bạn. Các lệnh mà bạn gõ sẽ theo đuổi X center: 8.0
Y center: 2.0
6. Trên Windows, tên của Python 3 thực thi thường là X center: 8.0
Y center: 2.0
8, vì vậy bạn nên chạy các tập lệnh Python bằng cách nhập X center: 8.0
Y center: 2.0
9 sau X center: 8.0
Y center: 2.0
6.Bất kể hệ điều hành của bạn là gì, đầu ra từ các tập lệnh Python mà bạn sử dụng trong bài viết này sẽ giống nhau, vì vậy chỉ có kiểu đầu vào Linux và MacOS được hiển thị trong bài viết này và dòng đầu vào sẽ bắt đầu tại
X center: 8.0
Y center: 2.0
1.Bây giờ bạn nên thực thi tập lệnh
X center: 8.0
Y center: 4
0 từ dòng lệnh, như được hiển thị bên dưới:args = parser.parse_args[]
3Trong ví dụ này, bạn có thể thấy rằng
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 có giá trị X center: 2
Y center: 4
4, trong đó các ký hiệu báo giá [X center: 2
Y center: 4
5] cho bạn biết rằng giá trị có loại chuỗi.Hãy nhớ rằng, trong Python, không có sự khác biệt giữa các chuỗi được xác định bằng các trích dẫn đơn [
X center: 2
Y center: 4
5] và trích dẫn kép [X center: 2
Y center: 4
7]. Bạn có thể đọc thêm về việc xác định chuỗi trong các loại dữ liệu cơ bản trong Python.Bạn sẽ tìm thấy đầu ra giống hệt nhau nếu bạn bao gồm một dòng shebang trong tập lệnh của bạn và thực hiện trực tiếp nó [
X center: 2
Y center: 4
8] hoặc sử dụng ma thuật X center: 2
Y center: 4
9 trong ipython hoặc máy tính xách tay Jupyter.Bạn cũng có thể thấy các tập lệnh Python được thực thi từ trong các gói bằng cách thêm đối số
import mytest
mytest.main[["-x","7","-y","6"]]
0 vào lệnh. Thông thường, bạn sẽ thấy điều này được đề xuất khi bạn sử dụng import mytest
mytest.main[["-x","7","-y","6"]]
1: import mytest
mytest.main[["-x","7","-y","6"]]
2.Thêm đối số
import mytest
mytest.main[["-x","7","-y","6"]]
0 chạy mã trong mô -đun import mytest
mytest.main[["-x","7","-y","6"]]
4 của gói. Bạn có thể tìm thêm thông tin về tệp import mytest
mytest.main[["-x","7","-y","6"]]
4 trong cách xuất bản gói Python nguồn mở lên PYPI.Trong cả ba trường hợp này,
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 có cùng giá trị: chuỗi X center: 2
Y center: 4
4.Nhập vào một mô -đun hoặc trình thông dịch tương tác
Bây giờ, hãy để một cách nhìn vào cách thứ hai mà trình thông dịch Python sẽ thực thi mã của bạn: nhập. Khi bạn đang phát triển một mô -đun hoặc tập lệnh, rất có thể bạn sẽ muốn tận dụng các mô -đun mà người khác đã xây dựng, điều mà bạn có thể làm với từ khóa
import mytest
mytest.main[["-x","7","-y","6"]]
8.Trong quá trình nhập, Python thực hiện các câu lệnh được xác định trong mô -đun được chỉ định [nhưng chỉ lần đầu tiên bạn nhập mô -đun]. Để chứng minh kết quả nhập tệp
X center: 8.0
Y center: 4
0 của bạn, hãy khởi động trình thông dịch Python tương tác và sau đó nhập tệp X center: 8.0
Y center: 4
0 của bạn:>>>
args = parser.parse_args[]
4
Trong đầu ra mã này, bạn có thể thấy rằng trình thông dịch Python thực hiện ba cuộc gọi đến
X center: 8.0
Y center: 4
1. Hai dòng đầu ra đầu tiên giống hệt như khi bạn thực thi tệp dưới dạng tập lệnh trên dòng lệnh vì không có biến nào trong một trong hai dòng đầu tiên. Tuy nhiên, có một sự khác biệt về đầu ra từ X center: 8.0
Y center: 4
1 thứ ba.Khi trình thông dịch Python nhập mã, giá trị của
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 được đặt là giống như tên của mô -đun đang được nhập. Bạn có thể thấy điều này trong dòng thứ ba của đầu ra ở trên. import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 có giá trị X center: 7.0
Y center: 6.0
5, là tên của tệp X center: 8.0
Y center: 2.0
0 mà Python đang nhập từ.Lưu ý rằng nếu bạn
import mytest
mytest.main[["-x","7","-y","6"]]
8 lại mô -đun mà không bỏ Python, sẽ không có đầu ra.Thực tiễn tốt nhất cho các chức năng chính của Python
Bây giờ bạn có thể thấy sự khác biệt trong cách Python xử lý các chế độ thực thi khác nhau của nó, nó rất hữu ích cho bạn để biết một số thực tiễn tốt nhất để sử dụng. Chúng sẽ được áp dụng bất cứ khi nào bạn muốn viết mã mà bạn có thể chạy dưới dạng tập lệnh và nhập trong một mô -đun khác hoặc phiên tương tác.
Bạn sẽ tìm hiểu về bốn thực tiễn tốt nhất để đảm bảo rằng mã của bạn có thể phục vụ mục đích kép:
- Đặt hầu hết các mã vào một chức năng hoặc lớp.
- Sử dụng
6 để kiểm soát việc thực thi mã của bạn.import argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
- Tạo một chức năng gọi là
5 để chứa mã bạn muốn chạy.import argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
- Gọi các chức năng khác từ
5.import argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
Đặt hầu hết các mã vào một chức năng hoặc lớp học
Hãy nhớ rằng trình thông dịch Python thực thi tất cả các mã trong một mô -đun khi nhập mô -đun. Đôi khi mã bạn viết sẽ có các tác dụng phụ mà bạn muốn người dùng kiểm soát, chẳng hạn như:
- Chạy một tính toán mất nhiều thời gian
- Ghi vào một tệp trên đĩa
- In thông tin sẽ làm lộn xộn thiết bị đầu cuối của người dùng
Trong những trường hợp này, bạn muốn người dùng kiểm soát việc kích hoạt việc thực thi mã này, thay vì để trình thông dịch Python thực thi mã khi nhập mô -đun của bạn.
Do đó, thực tiễn tốt nhất là bao gồm hầu hết các mã bên trong một hàm hoặc một lớp. Điều này là do khi trình thông dịch Python gặp phải từ khóa
def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
1 hoặc def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
2, nó chỉ lưu trữ các định nghĩa đó để sử dụng sau này và thực sự thực hiện chúng cho đến khi bạn nói với nó.include most code inside a function or a class. This is because when the Python interpreter encounters the def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
1 or def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
2
keywords, it only stores those definitions for later use and doesn’t actually execute them until you tell it to.Lưu mã bên dưới vào một tệp có tên
def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
3 để chứng minh ý tưởng này:args = parser.parse_args[]
5Trong mã này, trước tiên bạn nhập
def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
4 từ mô -đun def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
5.def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
4 tạm dừng trình thông dịch trong nhiều giây bạn đưa ra như một đối số và sẽ tạo ra một chức năng mất nhiều thời gian để chạy cho ví dụ này. Tiếp theo, bạn sử dụng X center: 8.0
Y center: 4
1 để in một câu mô tả mục đích của mã này.Sau đó, bạn xác định một hàm gọi là
def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8 thực hiện năm điều:- In một số đầu ra để nói với người dùng rằng việc xử lý dữ liệu đang bắt đầu
- Sửa đổi dữ liệu đầu vào
- Tạm dừng việc thực hiện trong ba giây bằng cách sử dụng
4def main[]: print["Hello World!"] if __name__ == "__main__": main[]
- In một số đầu ra để nói với người dùng rằng việc xử lý đã hoàn thành
- Trả về dữ liệu đã sửa đổi
Thực hiện tệp thực hành tốt nhất trên dòng lệnh
Bây giờ, điều gì sẽ xảy ra khi bạn thực thi tệp này dưới dạng tập lệnh trên dòng lệnh?
Trình thông dịch Python sẽ thực thi các dòng
args = parser.parse_args[]
00 và X center: 8.0
Y center: 4
1 nằm ngoài định nghĩa hàm, sau đó nó sẽ tạo định nghĩa của hàm gọi là def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8. Sau đó, tập lệnh sẽ thoát mà không làm gì nữa, vì tập lệnh không có bất kỳ mã nào thực thi def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8.Khối mã bên dưới hiển thị kết quả của việc chạy tệp này dưới dạng tập lệnh:
args = parser.parse_args[]
6Đầu ra mà chúng ta có thể thấy ở đây là kết quả của
X center: 8.0
Y center: 4
1 đầu tiên. Lưu ý rằng nhập từ def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
5 và xác định def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8 không tạo ra đầu ra. Cụ thể, các đầu ra của các cuộc gọi đến X center: 8.0
Y center: 4
1 nằm trong định nghĩa của def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8 không được in!Nhập tệp thực hành tốt nhất trong một mô -đun khác hoặc trình thông dịch tương tác
Khi bạn nhập tệp này trong phiên tương tác [hoặc mô -đun khác], trình thông dịch Python sẽ thực hiện chính xác các bước giống như khi nó thực thi tệp dưới dạng tập lệnh.
Khi trình thông dịch Python nhập tệp, bạn có thể sử dụng bất kỳ biến, lớp hoặc chức năng nào được xác định trong mô -đun mà bạn đã nhập. Để chứng minh điều này, chúng tôi sẽ sử dụng trình thông dịch Python tương tác. Bắt đầu trình thông dịch tương tác và sau đó nhập
args = parser.parse_args[]
09:>>>
args = parser.parse_args[]
7Đầu ra duy nhất từ việc nhập tệp
def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
3 là từ cuộc gọi X center: 8.0
Y center: 4
1 đầu tiên được xác định bên ngoài def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8. Nhập từ def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
5 và xác định def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8 không tạo ra đầu ra, giống như khi bạn thực thi mã từ dòng lệnh.Sử dụng args = parser.parse_args[]
15 để kiểm soát việc thực thi mã của bạn
args = parser.parse_args[]
Điều gì sẽ xảy ra nếu bạn muốn
def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8 thực thi khi bạn chạy tập lệnh từ dòng lệnh nhưng không phải khi trình thông dịch Python nhập tệp?Bạn có thể sử dụng thành ngữ
args = parser.parse_args[]
15 để xác định bối cảnh thực thi và chỉ chạy có điều kiện def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8 khi import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 bằng python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
4. Thêm mã bên dưới vào cuối tệp def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
3 của bạn:execution context and conditionally run
def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8 only when import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 is equal to python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
4. Add the code below to the bottom of your def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
3 file:args = parser.parse_args[]
8Trong mã này, bạn đã thêm một câu lệnh có điều kiện kiểm tra giá trị của
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6. Điều kiện này sẽ đánh giá đến python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
6 khi import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 bằng với chuỗi python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
4. Hãy nhớ rằng giá trị đặc biệt của python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
4 cho biến import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 có nghĩa là trình thông dịch Python đang thực thi tập lệnh của bạn và không nhập nó.Bên trong khối có điều kiện, bạn đã thêm bốn dòng mã [dòng 12, 13, 14 và 15]:
- Dòng 12 và 13: Bạn đang tạo một biến
28 lưu trữ dữ liệu mà bạn đã thu được từ web và in nó. You are creating a variableargs = parser.parse_args[]
28 that stores the data you’ve acquired from the Web and printing it.args = parser.parse_args[]
- Dòng 14: Bạn đang xử lý dữ liệu. You are processing the data.
- Dòng 15: Bạn đang in dữ liệu sửa đổi. You are printing the modified data.
Bây giờ, hãy chạy tập lệnh
def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
3 của bạn từ dòng lệnh để xem đầu ra sẽ thay đổi như thế nào:args = parser.parse_args[]
9Đầu tiên, đầu ra cho thấy kết quả của cuộc gọi
X center: 8.0
Y center: 4
1 bên ngoài def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8.Sau đó, giá trị của
args = parser.parse_args[]
28 được in. Điều này đã xảy ra vì biến import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 có giá trị python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
4 khi trình thông dịch Python thực thi tệp dưới dạng tập lệnh, do đó câu lệnh có điều kiện được đánh giá là python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
6.Tiếp theo, tập lệnh của bạn được gọi là
def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8 và vượt qua args = parser.parse_args[]
28 để sửa đổi. Khi def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8 thực thi, nó in một số thông báo trạng thái vào đầu ra. Cuối cùng, giá trị của args = parser.parse_args[]
39 được in.Bây giờ bạn nên kiểm tra những gì xảy ra khi bạn nhập tệp
def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
3 từ trình thông dịch tương tác [hoặc mô -đun khác]. Ví dụ dưới đây cho thấy tình huống này:>>>
args = parser.parse_args[]
7Lưu ý rằng bạn nhận được hành vi tương tự như trước khi bạn thêm câu lệnh có điều kiện vào cuối tệp! Điều này là do biến
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 có giá trị args = parser.parse_args[]
42, do đó, Python đã không thực thi mã bên trong khối, bao gồm def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8, vì câu lệnh có điều kiện được đánh giá là args = parser.parse_args[]
44.Tạo một hàm gọi là main [] để chứa mã bạn muốn chạy
Bây giờ bạn có thể viết mã Python có thể được chạy từ dòng lệnh dưới dạng tập lệnh và được nhập mà không có tác dụng phụ không mong muốn. Tiếp theo, bạn sẽ tìm hiểu về cách viết mã của mình để giúp các lập trình viên Python khác dễ dàng làm theo những gì bạn muốn nói.
Nhiều ngôn ngữ, chẳng hạn như C, C ++, Java và một số ngôn ngữ khác, xác định một hàm đặc biệt phải được gọi là
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 mà hệ điều hành sẽ tự động gọi khi thực thi chương trình được biên dịch. Hàm này thường được gọi là điểm nhập vì đó là nơi thực hiện vào chương trình.entry point because it is where execution enters the program.Ngược lại, Python không có chức năng đặc biệt đóng vai trò là điểm nhập cảnh vào một tập lệnh. Bạn thực sự có thể cung cấp chức năng điểm nhập trong tập lệnh Python bất kỳ tên nào bạn muốn!
Mặc dù Python không gán bất kỳ ý nghĩa nào cho một hàm có tên
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5, nhưng thực tế tốt nhất là đặt tên cho chức năng điểm nhập import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 dù sao đi nữa. Bằng cách đó, bất kỳ lập trình viên nào khác đọc tập lệnh của bạn ngay lập tức biết rằng hàm này là điểm khởi đầu của mã hoàn thành nhiệm vụ chính của tập lệnh.name the entry point function import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 anyways. That way, any other programmers who read your script immediately know that this function is the starting point of the code that accomplishes the primary task of the script.Ngoài ra,
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 nên chứa bất kỳ mã nào bạn muốn chạy khi trình thông dịch Python thực thi tệp. Điều này tốt hơn so với việc đặt mã trực tiếp vào khối có điều kiện vì người dùng có thể sử dụng lại import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 nếu họ nhập mô -đun của bạn.Thay đổi tệp
def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
3 để trông giống như mã bên dưới:import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
1Trong ví dụ này, bạn đã thêm định nghĩa của
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 bao gồm mã trước đây bên trong khối có điều kiện. Sau đó, bạn đã thay đổi khối có điều kiện để nó thực thi import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5. Nếu bạn chạy mã này dưới dạng tập lệnh hoặc nhập nó, bạn sẽ nhận được đầu ra giống như trong phần trước.Gọi các chức năng khác từ main []
Một thực tế phổ biến khác trong Python là có
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 thực thi các chức năng khác, thay vì bao gồm mã thực hiện nhiệm vụ trong import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5. Điều này đặc biệt hữu ích khi bạn có thể soạn thảo nhiệm vụ tổng thể của mình từ một số tác vụ nhỏ hơn có thể thực thi độc lập.have import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 execute other functions, rather than including the task-accomplishing code in import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5. This is especially useful when you can compose your overall task from several smaller sub-tasks that can execute independently.Ví dụ: bạn có thể có một tập lệnh làm như sau:
- Đọc tệp dữ liệu từ nguồn có thể là cơ sở dữ liệu, tệp trên đĩa hoặc API Web
- Xử lý dữ liệu
- Ghi dữ liệu được xử lý vào một vị trí khác
Nếu bạn thực hiện từng tác vụ phụ này trong các chức năng riêng biệt, thì thật dễ dàng để bạn [hoặc người dùng khác] sử dụng lại một vài bước và bỏ qua các bước bạn không muốn. Sau đó, bạn có thể tạo một quy trình công việc mặc định trong
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 và bạn có thể có tốt nhất cả hai thế giới.Có nên áp dụng thực tiễn này cho mã của bạn hay không là một cuộc gọi phán xét từ phía bạn. Chia công việc thành một số chức năng giúp tái sử dụng dễ dàng hơn nhưng làm tăng độ khó cho người khác đang cố gắng giải thích mã của bạn vì chúng phải theo dõi một số bước nhảy trong luồng của chương trình.
Sửa đổi tệp
def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
3 của bạn để nó trông giống như mã bên dưới:import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
2Trong mã ví dụ này, 10 dòng đầu tiên của tệp có cùng nội dung mà chúng có trước đây. Định nghĩa chức năng thứ hai trên dòng 12 tạo và trả về một số dữ liệu mẫu và định nghĩa hàm thứ ba trên dòng 17 mô phỏng ghi dữ liệu đã sửa đổi vào cơ sở dữ liệu.
Trên dòng 21,
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 được xác định. Trong ví dụ này, bạn đã sửa đổi import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 để lần lượt gọi các chức năng đọc dữ liệu, xử lý dữ liệu và ghi dữ liệu.Đầu tiên,
args = parser.parse_args[]
28 được tạo từ args = parser.parse_args[]
60. args = parser.parse_args[]
28 này được chuyển cho def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8, trả về args = parser.parse_args[]
39. Cuối cùng, args = parser.parse_args[]
39 được chuyển vào args = parser.parse_args[]
65.Hai dòng cuối cùng của tập lệnh là khối có điều kiện kiểm tra
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
6 và chạy import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 nếu câu lệnh python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
2 là python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py
6.Bây giờ, bạn có thể chạy toàn bộ đường ống xử lý từ dòng lệnh, như được hiển thị bên dưới:
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
3Trong đầu ra từ lần thực hiện này, bạn có thể thấy rằng trình thông dịch Python đã thực thi
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5, đã thực hiện args = parser.parse_args[]
60, def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8 và args = parser.parse_args[]
65. Tuy nhiên, bạn cũng có thể nhập tệp def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
3 và sử dụng lại def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8 cho một nguồn dữ liệu đầu vào khác, như được hiển thị bên dưới:>>>
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
4Trong ví dụ này, bạn đã nhập
args = parser.parse_args[]
76 và rút ngắn tên thành args = parser.parse_args[]
77 cho mã này.Quá trình nhập khiến trình thông dịch Python thực thi tất cả các dòng mã trong tệp
def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
3, do đó, đầu ra hiển thị dòng giải thích mục đích của tệp.Sau đó, bạn đã lưu trữ dữ liệu từ một tệp trong
args = parser.parse_args[]
28 thay vì đọc dữ liệu từ web. Sau đó, bạn đã sử dụng lại def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
8 và args = parser.parse_args[]
65 từ tệp def main[]:
print["Hello World!"]
if __name__ == "__main__":
main[]
3. Trong trường hợp này, bạn đã tận dụng việc tái sử dụng mã của mình thay vì xác định tất cả logic trong import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5.Tóm tắt chức năng chính của Python
Dưới đây là bốn thực tiễn tốt nhất về
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 trong Python mà bạn vừa thấy:Đặt mã mất nhiều thời gian để chạy hoặc có các hiệu ứng khác trên máy tính trong một hàm hoặc lớp, do đó bạn có thể kiểm soát chính xác khi mã đó được thực thi.
Sử dụng các giá trị khác nhau của
6 để xác định bối cảnh và thay đổi hành vi của mã của bạn bằng một câu lệnh có điều kiện.import argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
Bạn nên đặt tên cho chức năng điểm nhập của mình
5 để truyền đạt ý định của hàm, mặc dù Python không gán bất kỳ ý nghĩa đặc biệt nào cho một hàm có tênimport argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
5.import argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
-
Nếu bạn muốn sử dụng lại chức năng từ mã của mình, hãy xác định logic trong các chức năng bên ngoài
5 và gọi các chức năng đó trongimport argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
5.import argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
Sự kết luận
Xin chúc mừng! Bây giờ bạn đã biết cách tạo các chức năng Python
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5.Bạn đã học như sau:
Biết giá trị của biến
6 rất quan trọng để ghi mã phục vụ mục đích kép của tập lệnh thực thi và mô -đun có thể nhập.import argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
6 đảm nhận các giá trị khác nhau tùy thuộc vào cách bạn thực hiện tệp Python của mình.import argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
6 sẽ bằng:import argparse import sys def x[x_center, y_center]: print "X center:", x_center print "Y center:", y_center def main[args]: parser = argparse.ArgumentParser[description="Do something."] parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False] parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False] args = parser.parse_args[args] x[args.xcenter, args.ycenter] if __name__ == '__main__': main[sys.argv[1:]]
4 Khi tệp được thực thi từ dòng lệnh hoặc vớipython ./mytest.py -x 8 python ./mytest.py -x 8 -y 2 python ./mytest.py
95 [để thực thi tệp gói ____ ____ ____]args = parser.parse_args[]
- Tên của mô -đun, nếu mô -đun đang được nhập
- Các lập trình viên Python đã phát triển một tập hợp các thực tiễn tốt để sử dụng khi bạn muốn phát triển mã có thể tái sử dụng.
Bây giờ bạn đã sẵn sàng để viết một số mã chức năng Python
import argparse
import sys
def x[x_center, y_center]:
print "X center:", x_center
print "Y center:", y_center
def main[args]:
parser = argparse.ArgumentParser[description="Do something."]
parser.add_argument["-x", "--xcenter", type=float, default= 2, required=False]
parser.add_argument["-y", "--ycenter", type=float, default= 4, required=False]
args = parser.parse_args[args]
x[args.xcenter, args.ycenter]
if __name__ == '__main__':
main[sys.argv[1:]]
5 tuyệt vời!Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Xác định các chức năng chính trong Python This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Defining Main Functions in Python