Hướng dẫn how to call main function in python from another file - cách gọi hàm chính trong python từ một tệp khác

Question

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.

Nội dung chính Show

Một Python chính cơ bản ()
Chế độ thực thi trong Python
Thực thi từ dòng lệnh
Nhập vào một mô -đun hoặc trình thông dịch tương tác
Thực tiễn tốt nhất cho các chức năng chính của Python
Đặt hầu hết các mã vào một chức năng hoặc lớp học
Sử dụng args = parser.parse_args() 15 để kiểm soát việc thực thi mã của bạn
Tạo một hàm gọi là main () để chứa mã bạn muốn chạy
Gọi các chức năng khác từ main ()
Tóm tắt chức năng chính của Python
Sự kết luận
Làm thế nào để bạn chạy một chức năng chính từ một tệp khác trong Python?
Làm thế nào để bạn gọi một hàm trong một tệp từ một tệp khác trong Python?
Làm cách nào để gọi chức năng Python từ một thư mục khác?
Làm thế nào để bạn gọi một hàm chính trong tập lệnh Python?

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

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 biệt là gì và Python định nghĩa nó như thế nào

Tại sao bạn muốn sử dụ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:])

5 trong Python

Có những quy ước nào để xác đị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:])

5 trong Python

Thực hành tốt nhất là gì cho mã nào để đặt vào

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ủa bạn

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()

0

Trong 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
```
X center: 8.0
Y center: 2.0
```
0. Typically, a Python file is any file that contains code. Most Python files have the extension
```
X center: 8.0
Y center: 2.0
```
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()

1

Phầ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()

2

Phầ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()

3

Trong 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

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 để kiểm soát việc thực thi mã của bạn.

Tạo một chức năng 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 để chứa mã bạn muốn chạy.

Gọi các chức năng khác 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:])

5.

Đặ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()

5

Trong 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

def main():
    print("Hello World!")

if __name__ == "__main__":
    main()

4

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

Đ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()

8

Trong 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
args = parser.parse_args()
28 lưu trữ dữ liệu mà bạn đã thu được từ web và in nó. You are creating a variable
```
args = parser.parse_args()
```
28 that stores the data you’ve acquired from the Web and printing it.
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()

7

Lư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:])

1

Trong 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:])

2

Trong 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:])

3

Trong đầ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:])

4

Trong 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

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 để 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.

Bạn nên đặt tên cho chức năng điểm nhập 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:])

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ê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.

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

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à gọi các chức năng đó 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.

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

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 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:

```
python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py 
```
4 Khi tệp được thực thi từ dòng lệnh hoặc với
```
args = parser.parse_args()
```
95 (để thực thi tệp gói ____ ____ ____)
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

Làm thế nào để bạn chạy một chức năng chính từ một tệp khác trong Python?

Đối với chức năng chính của Python, chúng ta phải xác định một hàm và sau đó sử dụng nếu __name__ == '__main__' để thực thi chức năng này. Nếu tệp nguồn Python được nhập dưới dạng mô -đun, trình thông dịch Python sẽ đặt giá trị __name__ thành tên mô -đun, do đó, điều kiện nếu điều kiện sẽ trả về sai và phương thức chính sẽ không được thực thi.define a function and then use if __name__ == '__main__' condition to execute this function. If the python source file is imported as module, python interpreter sets the __name__ value to module name, so the if condition will return false and main method will not be executed.

Làm thế nào để bạn gọi một hàm trong một tệp từ một tệp khác trong Python?

Đưa ra một tệp Python, chúng ta cần gọi một hàm trong đó được xác định trong bất kỳ tệp Python nào khác ...

Tạo một tệp Python chứa các chức năng cần thiết ..

Tạo một tệp Python khác và nhập tệp Python trước đó vào đó ..

Gọi các chức năng được xác định trong tệp đã nhập ..

Làm cách nào để gọi chức năng Python từ một thư mục khác?

Cách pythonic nhất để nhập một mô -đun từ một thư mục khác là đặt một tệp trống có tên __init__.py vào thư mục đó và sử dụng đường dẫn tương đối với ký hiệu dấu chấm.Ví dụ: một mô -đun trong thư mục chính sẽ được nhập từ .. Nhập mô -đun.place an empty file named __init__.py into that folder and use the relative path with the dot notation. For example, a module in the parent folder would be imported with from .. import module .

Làm thế nào để bạn gọi một hàm chính trong tập lệnh Python?

Xác định các chức năng chính trong Python..

Đặt hầu hết các mã vào một chức năng hoặc lớp ..

Sử dụng nếu __name__ == "__main__" để kiểm soát việc thực thi mã của bạn ..

Tạo một hàm gọi là main () để chứa mã bạn muốn chạy ..

Gọi các chức năng khác từ main ().

Tóm tắt chức năng chính của Python thực tiễn tốt nhất ..

programming python Python main function __Main__ Python ModuleNotFoundError

Hướng dẫn how to call main function in python from another file - cách gọi hàm chính trong python từ một tệp khác

Một Python chính cơ bản ()

Chế độ thực thi trong Python

Thực thi từ dòng lệnh

Nhập vào một mô -đun hoặc trình thông dịch tương tác

Thực tiễn tốt nhất cho các chức năng chính của Python

Đặt hầu hết các mã vào một chức năng hoặc lớp học

Sử dụng args = parser.parse_args() 15 để kiểm soát việc thực thi mã của bạn

Tạo một hàm gọi là main () để chứa mã bạn muốn chạy

Gọi các chức năng khác từ main ()

Tóm tắt chức năng chính của Python

Sự kết luận

Làm thế nào để bạn chạy một chức năng chính từ một tệp khác trong Python?

Làm thế nào để bạn gọi một hàm trong một tệp từ một tệp khác trong Python?

Làm cách nào để gọi chức năng Python từ một thư mục khác?

Làm thế nào để bạn gọi một hàm chính trong tập lệnh Python?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội