Hướng dẫn what is if __ main __ in python? - nếu __ main __ trong python là gì?

Câu trả lời ngắn

Đó là mã Boilerplate bảo vệ người dùng khỏi việc vô tình gọi tập lệnh khi họ không có ý định. Dưới đây là một số vấn đề phổ biến khi người bảo vệ bị bỏ qua từ một kịch bản:

• Nếu bạn nhập tập lệnh không bảo vệ trong một tập lệnh khác (ví dụ:

  # What gets printed if foo is imported as a regular module
  before import
  before function_a
  before function_b
  before __name__ guard
  after __name__ guard
  

  7), thì tập lệnh sau sẽ kích hoạt bản trước để chạy vào thời điểm nhập và sử dụng các đối số dòng lệnh của tập lệnh thứ hai. Đây hầu như luôn luôn là một sai lầm.

• Nếu bạn có một lớp tùy chỉnh trong tập lệnh không bảo vệ và lưu nó vào tệp Pickle, thì việc giải nén nó trong một tập lệnh khác sẽ kích hoạt nhập tập lệnh không bảo vệ, với các vấn đề tương tự được nêu trong viên đạn trước đó.

Câu trả lời dài

Để hiểu rõ hơn về lý do và làm thế nào điều này quan trọng, chúng ta cần lùi một bước để hiểu làm thế nào Python khởi tạo các tập lệnh và cách điều này tương tác với cơ chế nhập mô -đun của nó.

Bất cứ khi nào trình thông dịch Python đọc một tệp nguồn, nó sẽ làm hai điều:

• Nó đặt một vài biến đặc biệt như

  # What gets printed if foo is imported as a regular module
  before import
  before function_a
  before function_b
  before __name__ guard
  after __name__ guard
  

  8, và sau đó

• Nó thực thi tất cả các mã được tìm thấy trong tệp.

Hãy xem cách thức hoạt động của nó và nó liên quan đến câu hỏi của bạn về các kiểm tra

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Mẫu mã

Hãy sử dụng một mẫu mã hơi khác nhau để khám phá cách nhập và tập lệnh hoạt động. Giả sử những điều sau đây là trong một tệp gọi là

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

# Suppose this is foo.py.

print("before import")
import math

print("before function_a")
def function_a():
    print("Function A")

print("before function_b")
def function_b():
    print("Function B {}".format(math.sqrt(100)))

print("before __name__ guard")
if __name__ == '__main__':
    function_a()
    function_b()
print("after __name__ guard")

Biến đặc biệt

Khi trình thông dịch Python đọc một tệp nguồn, trước tiên nó định nghĩa một vài biến đặc biệt. Trong trường hợp này, chúng tôi quan tâm đến biến

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Khi mô -đun của bạn là chương trình chính

Nếu bạn đang chạy mô -đun của mình (tệp nguồn) làm chương trình chính, ví dụ:

python foo.py

Trình thông dịch sẽ gán chuỗi được mã hóa cứng

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Khi mô -đun của bạn được nhập bởi người khác

Mặt khác, giả sử một số mô -đun khác là chương trình chính và nó nhập mô -đun của bạn. Điều này có nghĩa là có một tuyên bố như thế này trong chương trình chính hoặc trong một số mô -đun khác, chương trình chính nhập khẩu:

# Suppose this is in some other main program.
import foo

Trình thông dịch sẽ tìm kiếm tệp

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

Thực hiện mã của mô -đun

Sau khi các biến đặc biệt được thiết lập, trình thông dịch thực thi tất cả các mã trong mô -đun, một câu lệnh tại một thời điểm. Bạn có thể muốn mở một cửa sổ khác ở bên cạnh với mẫu mã để bạn có thể theo dõi cùng với lời giải thích này.

Luôn luôn

1. Nó in chuỗi

   # Suppose this is foo2.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo2 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   if __name__ == "__main__":
       print("m1")
       function_a()
       print("m2")
   print("t2")
         
   

   7 (không có báo giá).

2. Nó tải mô -đun

   # Suppose this is foo2.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo2 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   if __name__ == "__main__":
       print("m1")
       function_a()
       print("m2")
   print("t2")
         
   

   8 và gán nó cho một biến gọi là

   # Suppose this is foo2.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo2 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   if __name__ == "__main__":
       print("m1")
       function_a()
       print("m2")
   print("t2")
         
   

   8. Điều này tương đương với việc thay thế

   # Suppose this is foo3.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo3 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   print("m1")
   function_a()
   print("m2")
   print("t2")
   

   0 bằng cách sau (lưu ý rằng

   # Suppose this is foo3.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo3 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   print("m1")
   function_a()
   print("m2")
   print("t2")
   

   1 là hàm cấp thấp trong Python lấy chuỗi và kích hoạt nhập thực tế):

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")

1. Nó in chuỗi

   # Suppose this is foo3.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo3 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   print("m1")
   function_a()
   print("m2")
   print("t2")
   

   2.

2. Nó thực thi khối

   # Suppose this is foo3.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo3 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   print("m1")
   function_a()
   print("m2")
   print("t2")
   

   3, tạo một đối tượng hàm, sau đó gán đối tượng hàm đó cho một biến gọi là

   # Suppose this is foo3.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo3 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   print("m1")
   function_a()
   print("m2")
   print("t2")
   

   4.

3. Nó in chuỗi

   # Suppose this is foo3.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo3 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   print("m1")
   function_a()
   print("m2")
   print("t2")
   

   5.

4. Nó thực thi khối

   # Suppose this is foo3.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo3 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   print("m1")
   function_a()
   print("m2")
   print("t2")
   

   3 thứ hai, tạo một đối tượng hàm khác, sau đó gán nó cho một biến gọi là

   # Suppose this is foo3.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo3 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   print("m1")
   function_a()
   print("m2")
   print("t2")
   

   7.

5. Nó in chuỗi

   # Suppose this is foo3.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo3 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   print("m1")
   function_a()
   print("m2")
   print("t2")
   

   8.

Chỉ khi mô -đun của bạn là chương trình chính

1. Nếu mô -đun của bạn là chương trình chính, thì nó sẽ thấy rằng

   # What gets printed if foo is imported as a regular module
   before import
   before function_a
   before function_b
   before __name__ guard
   after __name__ guard
   

   8 thực sự đã được đặt thành

   # Suppose this is foo2.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo2 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   if __name__ == "__main__":
       print("m1")
       function_a()
       print("m2")
   print("t2")
         
   

   2 và nó gọi hai chức năng, in các chuỗi

   python foo.py
   

   01 và

   python foo.py
   

   02.

Chỉ khi mô -đun của bạn được nhập bởi người khác

1. .instead) If your module is not the main program but was imported by another one, then

   # What gets printed if foo is imported as a regular module
   before import
   before function_a
   before function_b
   before __name__ guard
   after __name__ guard
   

   8 will be

   # Suppose this is foo2.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo2 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   if __name__ == "__main__":
       print("m1")
       function_a()
       print("m2")
   print("t2")
         
   

   5, not

   # Suppose this is foo2.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo2 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   if __name__ == "__main__":
       print("m1")
       function_a()
       print("m2")
   print("t2")
         
   

   2, and it'll skip the body of the

   python foo.py
   

   06 statement.

Luôn luôn

1. Nó in chuỗi

   # Suppose this is foo2.py.
   import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
   
   def function_a():
       print("a1")
       from foo2 import function_b
       print("a2")
       function_b()
       print("a3")
   
   def function_b():
       print("b")
   
   print("t1")
   if __name__ == "__main__":
       print("m1")
       function_a()
       print("m2")
   print("t2")
         
   

   7 (không có báo giá).

Nó tải mô -đun

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

# Suppose this is foo3.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo3 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
print("m1")
function_a()
print("m2")
print("t2")

# Suppose this is foo3.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo3 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
print("m1")
function_a()
print("m2")
print("t2")

Nó in chuỗi

# Suppose this is foo3.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo3 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
print("m1")
function_a()
print("m2")
print("t2")

# What gets printed if foo is the main program
before import
before function_a
before function_b
before __name__ guard
Function A
Function B 10.0
after __name__ guard

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Nó thực thi khối # Suppose this is foo3.py. import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters def function_a(): print("a1") from foo3 import function_b print("a2") function_b() print("a3") def function_b(): print("b") print("t1") print("m1") function_a() print("m2") print("t2") 3, tạo một đối tượng hàm, sau đó gán đối tượng hàm đó cho một biến gọi là # Suppose this is foo3.py. import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters def function_a(): print("a1") from foo3 import function_b print("a2") function_b() print("a3") def function_b(): print("b") print("t1") print("m1") function_a() print("m2") print("t2") 4.

Nó in chuỗi

# Suppose this is foo3.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo3 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
print("m1")
function_a()
print("m2")
print("t2")

• Nó thực thi khối

  # Suppose this is foo3.py.
  import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
  
  def function_a():
      print("a1")
      from foo3 import function_b
      print("a2")
      function_b()
      print("a3")
  
  def function_b():
      print("b")
  
  print("t1")
  print("m1")
  function_a()
  print("m2")
  print("t2")
  

  3 thứ hai, tạo một đối tượng hàm khác, sau đó gán nó cho một biến gọi là

  # Suppose this is foo3.py.
  import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
  
  def function_a():
      print("a1")
      from foo3 import function_b
      print("a2")
      function_b()
      print("a3")
  
  def function_b():
      print("b")
  
  print("t1")
  print("m1")
  function_a()
  print("m2")
  print("t2")
  

  7.

• Nó in chuỗi

  # Suppose this is foo3.py.
  import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
  
  def function_a():
      print("a1")
      from foo3 import function_b
      print("a2")
      function_b()
      print("a3")
  
  def function_b():
      print("b")
  
  print("t1")
  print("m1")
  function_a()
  print("m2")
  print("t2")
  

  8.

• Chỉ khi mô -đun của bạn là chương trình chính

Nếu mô -đun của bạn là chương trình chính, thì nó sẽ thấy rằng

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

python foo.py

python foo.py

Thức ăn cho suy nghĩ

• Câu hỏi: Tôi có thể có nhiều khối kiểm tra

  # What gets printed if foo is imported as a regular module
  before import
  before function_a
  before function_b
  before __name__ guard
  after __name__ guard
  

  8 không? Trả lời: Thật lạ khi làm như vậy, nhưng ngôn ngữ sẽ không ngăn cản bạn.

• Giả sử những điều sau đây là trong

  python foo.py
  

  11. Điều gì xảy ra nếu bạn nói

  python foo.py
  

  12 trên dòng lệnh? Tại sao?

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

• Bây giờ, hãy tìm ra điều gì sẽ xảy ra nếu bạn xóa kiểm tra

  # What gets printed if foo is imported as a regular module
  before import
  before function_a
  before function_b
  before __name__ guard
  after __name__ guard
  

  8 trong

  python foo.py
  

  14:

# Suppose this is foo3.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo3 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
print("m1")
function_a()
print("m2")
print("t2")

• Điều này sẽ làm gì khi được sử dụng làm kịch bản? Khi được nhập dưới dạng mô -đun?

python foo.py

Tế bào thần kinh

4.6724 Huy hiệu vàng33 Huy hiệu bạc54 Huy hiệu đồng4 gold badges33 silver badges54 bronze badges

Đã trả lời ngày 7 tháng 1 năm 2009 lúc 4:26Jan 7, 2009 at 4:26

Ông Foozmr FoozMr Fooz

106K5 Huy hiệu vàng69 Huy hiệu bạc100 Huy hiệu đồng5 gold badges69 silver badges100 bronze badges

22

Khi tập lệnh của bạn được chạy bằng cách chuyển nó như một lệnh cho trình thông dịch Python,

python foo.py

Tất cả các mã ở cấp độ 0 được thực thi. Các chức năng và các lớp được xác định là, được xác định, nhưng không có mã nào của chúng được chạy. Không giống như các ngôn ngữ khác, không có chức năng

python foo.py

python foo.py

Trong trường hợp này, mã cấp cao nhất là một khối

python foo.py

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

python foo.py

Nếu tập lệnh của bạn được nhập vào một mô-đun khác, các định nghĩa chức năng và lớp khác nhau của nó sẽ được nhập và mã cấp cao nhất của nó sẽ được thực thi không được đáp ứng. Ví dụ cơ bản, hãy xem xét hai tập lệnh sau:

python foo.py

python foo.py

Bây giờ, nếu bạn gọi thông dịch viên là

python foo.py

Đầu ra sẽ là

python foo.py

Nếu bạn chạy

python foo.py

python foo.py

Bạn lấy

python foo.py

Do đó, khi mô -đun

python foo.py

python foo.py

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

TIỀN THƯỞNG

13K15 Huy hiệu vàng42 Huy hiệu bạc76 Huy hiệu đồng15 gold badges42 silver badges76 bronze badges

Đã trả lời ngày 7 tháng 1 năm 2009 lúc 4:28Jan 7, 2009 at 4:28

Adam Rosenfieldadam RosenfieldAdam Rosenfield

380K96 Huy hiệu vàng508 Huy hiệu bạc585 Huy hiệu Đồng96 gold badges508 silver badges585 bronze badges

2

Tạo hai tệp sau:

python foo.py

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Bây giờ chạy từng tệp riêng lẻ.

Chạy

python foo.py

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Khi

python foo.py

python foo.py

python foo.py

python foo.py

python foo.py

python foo.py

Chạy

python foo.py

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Khi chỉ thực thi tệp

python foo.py

python foo.py

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

python foo.py

python foo.py

Mateen Ulhaq

22.3K16 Huy hiệu vàng86 Huy hiệu bạc127 Huy hiệu đồng16 gold badges86 silver badges127 bronze badges

Đã trả lời ngày 7 tháng 1 năm 2009 lúc 11:35Jan 7, 2009 at 11:35

pi.pi.pi.

20,5K7 Huy hiệu vàng38 Huy hiệu bạc59 Huy hiệu Đồng7 gold badges38 silver badges59 bronze badges

0

python foo.py 41 làm gì?

Để phác thảo những điều cơ bản:

• Biến toàn cầu,

  # What gets printed if foo is imported as a regular module
  before import
  before function_a
  before function_b
  before __name__ guard
  after __name__ guard
  

  8, trong mô -đun là điểm nhập vào chương trình của bạn, là

  python foo.py
  

  43. Nếu không, đó là tên bạn nhập mô -đun theo.

• Vì vậy, mã trong khối

  python foo.py
  

  06 sẽ chỉ chạy nếu mô -đun là điểm nhập vào chương trình của bạn.

• Nó cho phép mã trong mô -đun có thể nhập bằng các mô -đun khác mà không thực hiện khối mã bên dưới khi nhập.

Tại sao chúng ta cần điều này?

Phát triển và kiểm tra mã của bạn

Giả sử bạn đang viết một tập lệnh Python được thiết kế để sử dụng làm mô -đun:

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Bạn có thể kiểm tra mô -đun bằng cách thêm cuộc gọi này của hàm vào phía dưới:

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

và chạy nó (trên dấu nhắc lệnh) với một cái gì đó như:

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Vấn đề

Tuy nhiên, nếu bạn muốn nhập mô -đun vào một tập lệnh khác:

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Khi nhập, hàm

python foo.py

python foo.py

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Và sau đó bạn sẽ phải nhớ liệu bạn có nhận xét cuộc gọi chức năng kiểm tra của mình hay không. Và sự phức tạp hơn này có nghĩa là bạn có thể quên, làm cho quá trình phát triển của bạn trở nên rắc rối hơn.

Một cách tốt hơn

Biến

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Bên trong một mô -đun nhập khẩu, đó là tên của mô -đun đó.

Nhưng bên trong mô -đun chính (hoặc phiên Python tương tác, tức là trình thông dịch đã đọc, eval, in vòng in hoặc thay thế), bạn đang chạy mọi thứ từ

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

Vì vậy, nếu bạn kiểm tra trước khi thực hiện:

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Với những điều trên, mã của bạn sẽ chỉ thực thi khi bạn chạy nó dưới dạng mô -đun chính (hoặc cố ý gọi nó từ một tập lệnh khác).

Một cách tốt hơn nữa

Tuy nhiên, có một cách pythonic để cải thiện điều này.

Điều gì sẽ xảy ra nếu chúng ta muốn chạy quy trình kinh doanh này từ bên ngoài mô -đun?

Nếu chúng ta đặt mã chúng ta muốn tập thể dục khi chúng ta phát triển và kiểm tra trong một chức năng như thế này và sau đó kiểm tra

python foo.py

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Bây giờ chúng tôi có một chức năng cuối cùng cho phần cuối của mô -đun sẽ chạy nếu chúng tôi chạy mô -đun làm mô -đun chính.

Nó sẽ cho phép mô -đun và các chức năng và lớp của nó được nhập vào các tập lệnh khác mà không cần chạy hàm

python foo.py

python foo.py

# Suppose this is in some other main program.
import foo

Thành ngữ này cũng có thể được tìm thấy trong tài liệu Python trong một lời giải thích về mô -đun

python foo.py

Mô -đun này biểu thị phạm vi (nếu không ẩn danh) trong đó chương trình chính của trình thông dịch thực thi - các lệnh được đọc từ đầu vào tiêu chuẩn, từ tệp tập lệnh hoặc từ một lời nhắc tương tác. Đó là môi trường trong đó tập lệnh có điều kiện thành ngữ của Stanza gây ra một kịch bản để chạy:

# Suppose this is in some other main program.
import foo

1

Đã trả lời ngày 23 tháng 11 năm 2013 lúc 4:38Nov 23, 2013 at 4:38

2

python foo.py

python foo.py

Mark Amery

133K78 Huy hiệu vàng395 Huy hiệu bạc444 Huy hiệu đồng78 gold badges395 silver badges444 bronze badges

Đã trả lời ngày 7 tháng 1 năm 2009 lúc 4:14Jan 7, 2009 at 4:14

Harley Holcomharley HolcombeHarley Holcombe

170K15 Huy hiệu vàng69 Huy hiệu bạc63 Huy hiệu Đồng15 gold badges69 silver badges63 bronze badges

2

python foo.py 41 làm gì?

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

Tuy nhiên, là trường hợp đặc biệt duy nhất, trong bất kỳ quy trình Python nào bạn chạy, như trong mycode.py:

# Suppose this is in some other main program.
import foo

Không gian tên toàn cầu ẩn danh khác được gán giá trị

python foo.py

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Do đó, bao gồm các dòng cuối cùng

# Suppose this is in some other main program.
import foo

• Ở cuối tập lệnh mycode.py của bạn,
• Khi nó là mô-đun chính, điểm nhập cảnh được điều hành bởi một quy trình Python,

sẽ khiến chức năng

python foo.py

Một lợi ích khác của việc sử dụng cấu trúc này: Bạn cũng có thể nhập mã của mình dưới dạng mô -đun trong một tập lệnh khác và sau đó chạy chức năng chính nếu và khi chương trình của bạn quyết định:

# Suppose this is in some other main program.
import foo

Mateen Ulhaq

22.3K16 Huy hiệu vàng86 Huy hiệu bạc127 Huy hiệu đồng16 gold badges86 silver badges127 bronze badges

Đã trả lời ngày 14 tháng 10 năm 2014 lúc 20:22Oct 14, 2014 at 20:22

0

Có rất nhiều sự khác nhau ở đây về các cơ chế của mã được đề cập, "làm thế nào", nhưng đối với tôi, không có ý nghĩa nào cho đến khi tôi hiểu "tại sao". Điều này nên đặc biệt hữu ích cho các lập trình viên mới.

Lấy tệp "ab.py":

# Suppose this is in some other main program.
import foo

Và tệp thứ hai "xy.py":

# Suppose this is in some other main program.
import foo

Mã này thực sự đang làm gì?

Khi bạn thực hiện

python foo.py

python foo.py

python foo.py

python foo.py

Trình thông dịch theo dõi các tập lệnh nào đang chạy với

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

Bất kỳ tập lệnh nào khác được gọi từ tập lệnh

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

python foo.py

python foo.py

Chúng ta hãy bước qua mã trên để hiểu những gì đang xảy ra, đầu tiên tập trung vào các dòng chưa được giải quyết và thứ tự chúng xuất hiện trong các tập lệnh. Hãy nhớ rằng chức năng đó - hoặc

# Suppose this is foo3.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo3 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
print("m1")
function_a()
print("m2")
print("t2")

• Mở xy.py là tệp 'home'; Gọi nó là

  # Suppose this is foo2.py.
  import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
  
  def function_a():
      print("a1")
      from foo2 import function_b
      print("a2")
      function_b()
      print("a3")
  
  def function_b():
      print("b")
  
  print("t1")
  if __name__ == "__main__":
      print("m1")
      function_a()
      print("m2")
  print("t2")
        
  

  2 trong biến

  # What gets printed if foo is imported as a regular module
  before import
  before function_a
  before function_b
  before __name__ guard
  after __name__ guard
  

  8.
• Nhập và mở tệp với

  python foo.py
  

  71.
• Oh, một chức năng. Tôi sẽ nhớ điều đó.
• OK, chức năng

  python foo.py
  

  77; Tôi chỉ học được điều đó. In 'một hàm trong tệp ab'.
• Phần cuối của tập tin; Quay lại

  # Suppose this is foo2.py.
  import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
  
  def function_a():
      print("a1")
      from foo2 import function_b
      print("a2")
      function_b()
      print("a3")
  
  def function_b():
      print("b")
  
  print("t1")
  if __name__ == "__main__":
      print("m1")
      function_a()
      print("m2")
  print("t2")
        
  

  2!
• Oh, một chức năng. Tôi sẽ nhớ điều đó.
• OK, chức năng

  python foo.py
  

  77; Tôi chỉ học được điều đó. In 'một hàm trong tệp ab'.
• Phần cuối của tập tin; Quay lại

  # Suppose this is foo2.py.
  import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters
  
  def function_a():
      print("a1")
      from foo2 import function_b
      print("a2")
      function_b()
      print("a3")
  
  def function_b():
      print("b")
  
  print("t1")
  if __name__ == "__main__":
      print("m1")
      function_a()
      print("m2")
  print("t2")
        
  

  2!
• Một cái khác.

Chức năng

python foo.py

Tại sao thực hiện điều này?

Hãy nhớ những gì tôi đã nói trước đó về báo cáo nhập khẩu? Khi bạn nhập một mô -đun, nó không chỉ 'nhận ra' nó và chờ thêm các hướng dẫn - nó thực sự chạy tất cả các hoạt động thực thi có trong tập lệnh. Vì vậy, đặt phần thịt của tập lệnh của bạn vào chức năng

python foo.py

Một lần nữa, sẽ có những ngoại lệ, nhưng thực tế phổ biến là

python foo.py

python foo.py

Nhưng mã hoạt động mà không có nó

Vâng đúng vậy. Các chức năng riêng biệt này có thể được gọi từ một tập lệnh nội tuyến không có trong hàm

python foo.py

python foo.py

Nhưng đó là một tập lệnh có lẽ không thể có các chức năng của nó được gọi là bên ngoài, bởi vì nếu nó làm ngay lập tức sẽ bắt đầu tính toán và gán các biến. Và rất có thể nếu bạn đang cố gắng sử dụng lại một hàm, tập lệnh mới của bạn có liên quan đủ chặt chẽ với quy mô cũ mà sẽ có các biến mâu thuẫn.

Trong việc chia ra các chức năng độc lập, bạn có khả năng sử dụng lại công việc trước đây của mình bằng cách gọi chúng vào một tập lệnh khác. Ví dụ: "example.py" có thể nhập "xy.py" và gọi

python foo.py

.

Đã trả lời ngày 29 tháng 9 năm 2016 lúc 4:33Sep 29, 2016 at 4:33

Joechojjoechojjoechoj

1.2999 huy hiệu bạc12 Huy hiệu đồng9 silver badges12 bronze badges

0

Mã theo

python foo.py

Ví dụ, hãy xem xét mô -đun sau

python foo.py

# Suppose this is in some other main program.
import foo

Khả năng đầu tiên: Nhập

python foo.py

# Suppose this is in some other main program.
import foo

Bây giờ nếu bạn gọi

python foo.py

# Suppose this is in some other main program.
import foo

Lưu ý rằng chỉ có câu lệnh

python foo.py

python foo.py

Khả năng thứ hai: Gọi

python foo.py

Bây giờ nếu bạn chạy

python foo.py

python foo.py

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

Để giải thích toàn diện hơn, bạn có thể đọc những gì

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Đã trả lời ngày 1 tháng 2 năm 2020 lúc 13:26Feb 1, 2020 at 13:26

1

Khi có một số câu lệnh nhất định trong mô-đun của chúng tôi (

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

python foo.py

Theo mặc định (khi mô -đun chạy dưới dạng chính, không được nhập), biến

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Nói tóm lại, sử dụng khối '

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Đã trả lời ngày 3 tháng 4 năm 2013 lúc 14:09Apr 3, 2013 at 14:09

Nabeel Ahmednabeel AhmedNabeel Ahmed

17,5K4 Huy hiệu vàng55 Huy hiệu bạc59 Huy hiệu đồng4 gold badges55 silver badges59 bronze badges

1

Nói một cách đơn giản,

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Vì vậy, nếu chúng ta có hai kịch bản;

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

và

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

Đầu ra từ thực thi script1 là

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

Và đầu ra từ thực thi Script2 là:

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

Như bạn có thể thấy,

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Giả sử bạn viết một kịch bản Python làm một cái gì đó tuyệt vời và bạn thực hiện một loạt các chức năng hữu ích cho các mục đích khác. Nếu tôi muốn sử dụng chúng, tôi chỉ có thể nhập tập lệnh của bạn và sử dụng chúng mà không cần thực hiện chương trình của bạn (cho rằng mã của bạn chỉ thực thi trong bối cảnh

python foo.py

Các mũi tên là liên kết nhập. Đối với ba mô -đun, mỗi mô -đun đang cố gắng bao gồm mã mô -đun trước đó, có sáu tệp (chín, đếm các tệp triển khai) và năm liên kết. Điều này gây khó khăn cho việc đưa mã khác vào dự án C trừ khi nó được biên dịch cụ thể là thư viện. Bây giờ hãy hình dung nó cho Python:

Bạn viết một mô -đun và nếu ai đó muốn sử dụng mã của bạn, họ chỉ cần nhập nó và biến

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Đã trả lời ngày 15 tháng 10 năm 2016 lúc 9:07Oct 15, 2016 at 9:07

redbanditredbanditredbandit

2.07215 huy hiệu bạc11 huy hiệu đồng15 silver badges11 bronze badges

1

Hãy nhìn vào câu trả lời theo cách trừu tượng hơn:

Giả sử chúng ta có mã này trong

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

Khối A và B được chạy khi chúng ta đang chạy

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Nhưng chỉ cần chặn A (và không B) được chạy khi chúng ta đang chạy một mô -đun khác, ví dụ

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Kubuntu

2.5251 Huy hiệu vàng21 Huy hiệu bạc24 Huy hiệu đồng1 gold badge21 silver badges24 bronze badges

Đã trả lời ngày 20 tháng 1 năm 2015 lúc 17:48Jan 20, 2015 at 17:48

AlisaalisaAlisa

2.7723 huy hiệu vàng30 huy hiệu bạc44 Huy hiệu đồng3 gold badges30 silver badges44 bronze badges

0

Để ngắn gọn, bạn cần biết một số điểm:

1. # It's as if the interpreter inserts this at the top
   # of your module when run as the main program.
   __name__ = "__main__" 
   

   19 Hành động thực sự chạy tất cả những gì có thể chạy trong

   python foo.py
   

   29, có nghĩa là mỗi dòng trong

   python foo.py
   

   29

2. Vì điểm 1, bạn có thể không muốn mọi thứ được chạy trong

   python foo.py
   

   29 khi nhập nó

3. Để giải quyết vấn đề ở điểm 2, Python cho phép bạn sử dụng kiểm tra điều kiện

4. # What gets printed if foo is imported as a regular module
   before import
   before function_a
   before function_b
   before __name__ guard
   after __name__ guard
   

   8 là một biến ẩn trong tất cả các mô -đun

   python foo.py
   

   08:

• Khi

  python foo.py
  

  29 được

  # It's as if the interpreter inserts this at the top
  # of your module when run as the main program.
  __name__ = "__main__" 
  

  26ed, giá trị của

  # What gets printed if foo is imported as a regular module
  before import
  before function_a
  before function_b
  before __name__ guard
  after __name__ guard
  

  8 của mô -đun

  python foo.py
  

  29 được đặt thành tên tệp của nó "

  # It's as if the interpreter inserts this at the top
  # of your module when run as the main program.
  __name__ = "__main__" 
  

  29"
• Khi

  python foo.py
  

  29 được chạy trực tiếp bằng cách sử dụng "

  python foo.py
  

  28", giá trị của

  # What gets printed if foo is imported as a regular module
  before import
  before function_a
  before function_b
  before __name__ guard
  after __name__ guard
  

  8 được đặt thành chuỗi

  python foo.py
  

  52

1. Dựa trên cơ chế làm thế nào Python đặt biến

   # What gets printed if foo is imported as a regular module
   before import
   before function_a
   before function_b
   before __name__ guard
   after __name__ guard
   

   8 cho mỗi mô -đun, bạn có biết cách đạt được điểm 3 không? Câu trả lời khá dễ dàng, phải không? Sử dụng điều kiện IF:

   # It's as if the interpreter inserts this at the top
   # of your module when run as the main program.
   __name__ = "__main__" 
   

   35

• Sau đó

  python foo.py
  

  28 sẽ chạy phần

  # It's as if the interpreter inserts this at the top
  # of your module when run as the main program.
  __name__ = "__main__" 
  

  37
• và

  # It's as if the interpreter inserts this at the top
  # of your module when run as the main program.
  __name__ = "__main__" 
  

  19 sẽ bỏ qua phần

  # It's as if the interpreter inserts this at the top
  # of your module when run as the main program.
  __name__ = "__main__" 
  

  37

1. Bạn thậm chí có thể đặt nếu

   # It's as if the interpreter inserts this at the top
   # of your module when run as the main program.
   __name__ = "__main__" 
   

   40 tùy thuộc vào nhu cầu chức năng của bạn, nhưng hiếm khi

Điều quan trọng mà Python đặc biệt là điểm 4! Phần còn lại chỉ là logic cơ bản.

Tôi đã đọc rất nhiều trong suốt các câu trả lời trên trang này. Tôi sẽ nói, nếu bạn biết điều đó, chắc chắn bạn sẽ hiểu những câu trả lời đó, nếu không, bạn vẫn còn bối rối.

Đã trả lời ngày 24 tháng 6 năm 2018 lúc 15:48Jun 24, 2018 at 15:48

kiểm trajack

1.61710 Huy hiệu bạc25 Huy hiệu Đồng10 silver badges25 bronze badges

1

Khi bạn chạy Python tương tác, biến

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

Đã trả lời ngày 11 tháng 12 năm 2013 lúc 11:23Dec 11, 2013 at 11:23

ZainzainZain

1.2061 Huy hiệu vàng16 Huy hiệu bạc26 Huy hiệu đồng1 gold badge16 silver badges26 bronze badges

Consider:

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

Nó kiểm tra xem thuộc tính

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

python foo.py

python foo.py

Tuy nhiên, nếu tập lệnh Python của bạn được sử dụng bởi một mô -đun, bất kỳ mã nào bên ngoài câu lệnh

python foo.py

python foo.py

Tripleee

165K27 Huy hiệu vàng250 Huy hiệu bạc298 Huy hiệu Đồng27 gold badges250 silver badges298 bronze badges

Đã trả lời ngày 22 tháng 8 năm 2017 lúc 18:53Aug 22, 2017 at 18:53

LarrylarryLarry

1.2722 Huy hiệu vàng14 Huy hiệu bạc20 Huy hiệu Đồng2 gold badges14 silver badges20 bronze badges

0

Trước khi giải thích bất cứ điều gì về

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# What gets printed if foo is imported as a regular module before import before function_a before function_b before __name__ guard after __name__ guard 8 là gì?

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Đây là một chuỗi (toàn cầu như đã đề cập ở trên) như được chỉ ra bởi

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Ở đâu

Nó không chỉ có thể được sử dụng trong các tập lệnh mà còn có thể được tìm thấy trong cả phiên dịch và mô -đun/gói.

Interpreter:

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

Script:

test_file.py:

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

Dẫn đến

python foo.py

Mô -đun hoặc gói:

somefile.py:

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")

test_file.py:

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")

Dẫn đến

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Lưu ý rằng khi được sử dụng trong một gói hoặc mô -đun,

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Bạn sẽ thấy rằng, trong đó

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

Thực tiễn

Trở thành một biến có nghĩa là giá trị của nó có thể được ghi đè ("có thể" không có nghĩa là "nên"), ghi đè lên giá trị của

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Luôn luôn cho rằng giá trị của

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

Example:

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")

Nó được coi là thực hành tốt nói chung để bao gồm

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Bây giờ để trả lời # It's as if the interpreter inserts this at the top # of your module when run as the main program. __name__ = "__main__" 01:

Bây giờ chúng ta biết hành vi của

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

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

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

Nếu thực sự

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

Điều này cho chúng tôi biết rằng nếu tệp chạy là tệp chính (hoặc bạn đang chạy trực tiếp từ trình thông dịch) thì điều kiện đó phải thực thi. Nếu đó là một gói thì nó không nên và giá trị sẽ không phải là

python foo.py

Mô -đun

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Biến thể

Cũng có thể làm những điều khác, ít phổ biến nhưng hữu ích với

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Chỉ thực thi nếu tệp là mô -đun hoặc gói

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")

Chạy một điều kiện nếu tệp là cái chính và cái khác nếu nó không

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")

Bạn cũng có thể sử dụng nó để cung cấp các chức năng/tiện ích trợ giúp có thể chạy được trên các gói và mô -đun mà không cần sử dụng các thư viện phức tạp.

Nó cũng cho phép các mô -đun được chạy từ dòng lệnh dưới dạng các tập lệnh chính, cũng có thể rất hữu ích.

Tripleee

165K27 Huy hiệu vàng250 Huy hiệu bạc298 Huy hiệu Đồng27 gold badges250 silver badges298 bronze badges

Đã trả lời ngày 3 tháng 4 năm 2018 lúc 19:32Apr 3, 2018 at 19:32

XantiumxantiumXantium

10,6K10 Huy hiệu vàng58 Huy hiệu bạc87 Huy hiệu đồng10 gold badges58 silver badges87 bronze badges

0

Tôi nghĩ rằng tốt nhất là phá vỡ câu trả lời theo chiều sâu và bằng những từ đơn giản:

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

python foo.py

python foo.py

Do đó, giá trị của thuộc tính

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Đã trả lời ngày 30 tháng 11 năm 2016 lúc 6:47Nov 30, 2016 at 6:47

Taufiq Rahmantaufiq RahmanTaufiq Rahman

5.4652 Huy hiệu vàng36 Huy hiệu bạc43 Huy hiệu đồng2 gold badges36 silver badges43 bronze badges

Nó là một đặc biệt cho khi một tệp python được gọi từ dòng lệnh. Điều này thường được sử dụng để gọi hàm "chính ()" hoặc thực thi mã khởi động thích hợp khác, như xử lý đối số dòng lệnh.

Nó có thể được viết theo nhiều cách. Cái khác là:

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")

Tôi không nói rằng bạn nên sử dụng điều này trong mã sản xuất, nhưng nó phục vụ để minh họa rằng không có gì "kỳ diệu" về

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Nó chỉ là một quy ước để gọi một chức năng chính trong các tệp Python.

Đã trả lời ngày 24 tháng 1 năm 2013 lúc 13:48Jan 24, 2013 at 13:48

Giáo sư Falkenprof. FalkenProf. Falken

23.6K18 Huy hiệu vàng100 Huy hiệu bạc169 Huy hiệu đồng18 gold badges100 silver badges169 bronze badges

6

Có một số biến mà hệ thống (trình thông dịch Python) cung cấp cho các tệp nguồn (mô -đun). Bạn có thể nhận được các giá trị của họ bất cứ lúc nào bạn muốn, vì vậy, hãy để chúng tôi tập trung vào biến __name__/thuộc tính:__name__ variable/attribute:

Khi Python tải một tệp mã nguồn, nó thực thi tất cả các mã được tìm thấy trong đó. (Lưu ý rằng nó không gọi tất cả các phương thức và hàm được xác định trong tệp, nhưng nó xác định chúng.)

Trước khi trình thông dịch thực thi tệp mã nguồn, nó xác định một vài biến đặc biệt cho tệp đó; __name__ là một trong những biến đặc biệt mà Python tự động xác định cho mỗi tệp mã nguồn.__name__ is one of those special variables that Python automatically defines for each source code file.

Nếu Python đang tải tệp mã nguồn này làm chương trình chính (nghĩa là tệp bạn chạy), thì nó sẽ đặt biến __name__ đặc biệt cho tệp này có giá trị "__main__".__name__ variable for this file to have a value "__main__".

Nếu điều này được nhập từ một mô -đun khác, __name__ sẽ được đặt thành tên của mô -đun đó.__name__ will be set to that module's name.

Vì vậy, trong ví dụ của bạn một phần:

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")

có nghĩa là khối mã:

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")

sẽ chỉ được thực thi khi bạn chạy mô -đun trực tiếp; Khối mã sẽ không thực thi nếu một mô -đun khác đang gọi/nhập nó vì giá trị của __name__ sẽ không bằng "chính" trong trường hợp cụ thể đó.__name__ will not equal to "main" in that particular instance.

Hy vọng điều này sẽ giúp.

Đã trả lời ngày 25 tháng 11 năm 2015 lúc 12:26Nov 25, 2015 at 12:26

CodewizardCodewizardcodewizard

3763 Huy hiệu bạc8 Huy hiệu Đồng3 silver badges8 bronze badges

1

python foo.py

python foo.py

python foo.py

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")

Đã trả lời ngày 24 tháng 4 năm 2016 lúc 8:23Apr 24, 2016 at 8:23

Gr8 adakronthe gr8 adakronThe Gr8 Adakron

1.1721 Huy hiệu vàng12 Huy hiệu bạc14 Huy hiệu đồng1 gold badge12 silver badges14 bronze badges

Consider:

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")

Đầu ra cho những điều trên là

python foo.py

# What gets printed if foo is the main program
before import
before function_a
before function_b
before __name__ guard
Function A
Function B 10.0
after __name__ guard

Câu lệnh trên là đúng và in "Phương thức trực tiếp". Giả sử nếu họ nhập lớp này trong một lớp khác, nó không in "Phương thức trực tiếp" bởi vì, trong khi nhập, nó sẽ đặt

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Simhumileco

28.8K16 Huy hiệu vàng127 Huy hiệu bạc106 Huy hiệu đồng16 gold badges127 silver badges106 bronze badges

Đã trả lời ngày 22 tháng 6 năm 2016 lúc 10:47Jun 22, 2016 at 10:47

Nói một cách đơn giản:

Mã bạn thấy trong

python foo.py

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Tuy nhiên, nếu bạn muốn nhập tệp Python của mình

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

# Suppose this is in some other main program.
import foo

python foo.py

Tripleee

165K27 Huy hiệu vàng250 Huy hiệu bạc298 Huy hiệu Đồng27 gold badges250 silver badges298 bronze badges

Đã trả lời ngày 22 tháng 10 năm 2020 lúc 18:01Oct 22, 2020 at 18:01

Bạn có thể làm cho tệp có thể sử dụng được như một tập lệnh cũng như một mô -đun có thể nhập.script as well as an importable module.

fibo.py (một mô -đun có tên

# Suppose this is in some other main program.
import foo

# What gets printed if foo is the main program
before import
before function_a
before function_b
before __name__ guard
Function A
Function B 10.0
after __name__ guard

Tham khảo: https://docs.python.org/3.5/tutorial/modules.html

Đã trả lời ngày 13 tháng 3 năm 2017 lúc 21:44Mar 13, 2017 at 21:44

kgf3JfUtWkgf3JfUtWkgf3JfUtW

12.4K8 Huy hiệu vàng50 Huy hiệu bạc74 Huy hiệu đồng8 gold badges50 silver badges74 bronze badges

Lý giải cho việc

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

chủ yếu là để tránh các vấn đề khóa nhập khẩu sẽ phát sinh từ việc nhập mã trực tiếp. Bạn muốn

python foo.py

# Suppose this is in some other main program.
import foo

Một hiệu ứng phụ là bạn tự động đăng nhập vào một phương pháp hỗ trợ nhiều điểm nhập cảnh. Bạn có thể chạy chương trình của mình bằng

python foo.py

# Suppose this is in some other main program.
import foo

python foo.py

# Suppose this is in some other main program.
import foo

# Suppose this is in some other main program.
import foo

python foo.py

# Suppose this is in some other main program.
import foo

# Suppose this is in some other main program.
import foo

Đã trả lời ngày 22 tháng 9 năm 2017 lúc 18:32Sep 22, 2017 at 18:32

personal_cloudpersonal_cloudpersonal_cloud

3.6503 huy hiệu vàng25 Huy hiệu bạc32 Huy hiệu đồng3 gold badges25 silver badges32 bronze badges

0

Nếu bạn là người mới bắt đầu, có lẽ câu trả lời duy nhất bạn cần ngay bây giờ là mã này không cần thiết cho một tập lệnh đơn giản. Nó chỉ hữu ích nếu bạn muốn có thể

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

# Suppose this is in some other main program.
import foo

Trong các từ hơi khác nhau, người bảo vệ

# Suppose this is in some other main program.
import foo

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

Nói chi tiết hơn một chút, giả sử bạn có một tập lệnh đơn giản

# Suppose this is in some other main program.
import foo

# What gets printed if foo is the main program
before import
before function_a
before function_b
before __name__ guard
Function A
Function B 10.0
after __name__ guard

Bây giờ, nếu bạn chỉ cần chạy

# Suppose this is in some other main program.
import foo

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

# What gets printed if foo is the main program
before import
before function_a
before function_b
before __name__ guard
Function A
Function B 10.0
after __name__ guard

Bây giờ, bạn không thể

# Suppose this is in some other main program.
import foo

Nếu bạn muốn có thể

# Suppose this is in some other main program.
import foo

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

# What gets printed if foo is the main program
before import
before function_a
before function_b
before __name__ guard
Function A
Function B 10.0
after __name__ guard

Bây giờ, nếu bạn

# Suppose this is in some other main program.
import foo

python foo.py

# Suppose this is in some other main program.
import foo

Trên thực tế, một thiết kế tốt hơn vẫn sẽ là cô lập phần có thể tái sử dụng (tính toán thực tế) khỏi đầu vào/đầu ra có thể nhìn thấy của người dùng:

# What gets printed if foo is the main program
before import
before function_a
before function_b
before __name__ guard
Function A
Function B 10.0
after __name__ guard

Bây giờ, bạn có thể

# Suppose this is in some other main program.
import foo

# Suppose this is in some other main program.
import foo

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

.

Tương tự, bạn có thể

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

python foo.py

Quay trở lại mã trong câu hỏi, tôi cũng sẽ chuyển mã từ

python foo.py

# What gets printed if foo is the main program
before import
before function_a
before function_b
before __name__ guard
Function A
Function B 10.0
after __name__ guard

Điều này thay đổi phạm vi của biến

# Suppose this is in some other main program.
import foo

python foo.py

# Suppose this is in some other main program.
import foo

(Không giống như trong các ngôn ngữ như C, tên

python foo.py

python foo.py

Đã trả lời ngày 30 tháng 10 năm 2021 lúc 9:46Oct 30, 2021 at 9:46

Tripleetripleeetripleee

165K27 Huy hiệu vàng250 Huy hiệu bạc298 Huy hiệu Đồng27 gold badges250 silver badges298 bronze badges

3

Mỗi mô -đun trong Python có một thuộc tính gọi là

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

# Suppose this is in some other main program.
import foo

# Suppose this is in some other main program.
import foo

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Ví dụ nhỏ để giải thích ngắn gọn.

Script test.py

# What gets printed if foo is the main program
before import
before function_a
before function_b
before __name__ guard
Function A
Function B 10.0
after __name__ guard

Chúng ta có thể thực hiện trực tiếp điều này như

# What gets printed if foo is the main program
before import
before function_a
before function_b
before __name__ guard
Function A
Function B 10.0
after __name__ guard

Đầu ra

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Bây giờ giả sử chúng ta gọi tập lệnh trên từ một tập lệnh khác:

Tập lệnh bên ngoài_calling.py

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Khi bạn thực hiện điều này,

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Đầu ra

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Bây giờ giả sử chúng ta gọi tập lệnh trên từ một tập lệnh khác:

Tập lệnh bên ngoài_calling.pyJun 12, 2019 at 9:28

Khi bạn thực hiện điều này,Rishi Bansal

Vì vậy, ở trên là tự giải thích rằng khi bạn gọi thử nghiệm từ một tập lệnh khác, nếu vòng lặp

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# Suppose this is in some other main program.
import foo

Đã trả lời ngày 12 tháng 6 năm 2019 lúc 9:28

1. Rishi Bansalrishi Bansal

2. 3,4772 Huy hiệu vàng24 Huy hiệu bạc44 Huy hiệu đồng

Câu trả lời này dành cho các lập trình viên Java học Python. Mỗi tệp Java thường chứa một lớp công khai. Bạn có thể sử dụng lớp đó theo hai cách:

Gọi lớp từ các tệp khác. Bạn chỉ cần nhập nó trong chương trình gọi.

Chạy lớp đứng một mình, cho mục đích thử nghiệm.18 gold badges135 silver badges203 bronze badges

Đối với trường hợp sau, lớp nên chứa một phương thức chính () tĩnh công khai. Trong Python, mục đích này được phục vụ bởi nhãn được xác định trên toàn cầu

python foo.py

EYLLLANESCRaja

227K18 Huy hiệu vàng135 Huy hiệu bạc203 Huy hiệu đồng11 silver badges13 bronze badges

0

Đã trả lời ngày 7 tháng 10 năm 2018 lúc 4:52

Rajaraja

96611 Huy hiệu bạc13 Huy hiệu đồng

Nếu tệp .py này được nhập bởi các tệp .py khác, mã trong câu lệnh

python foo.py

165K27 Huy hiệu vàng250 Huy hiệu bạc298 Huy hiệu Đồng27 gold badges250 silver badges298 bronze badges

Mỗi mô -đun trong Python có một thuộc tính gọi là

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

# Suppose this is in some other main program.
import foo

# Suppose this is in some other main program.
import foo

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

pah8Jpah8Jpah8J

Ví dụ nhỏ để giải thích ngắn gọn.7 silver badges15 bronze badges

Script test.py

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Chúng ta có thể thực hiện trực tiếp điều này nhưyou can see me.

Đầu ra

Bây giờ giả sử chúng ta gọi tập lệnh trên từ một tập lệnh khác:You can't see me.

Tập lệnh bên ngoài_calling.py

Khi bạn thực hiện điều này,Jul 30, 2019 at 16:22

Vì vậy, ở trên là tự giải thích rằng khi bạn gọi thử nghiệm từ một tập lệnh khác, nếu vòng lặp

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# Suppose this is in some other main program.
import foo

Đã trả lời ngày 12 tháng 6 năm 2019 lúc 9:28

Rishi Bansalrishi Bansal

3,4772 Huy hiệu vàng24 Huy hiệu bạc44 Huy hiệu đồng

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Câu trả lời này dành cho các lập trình viên Java học Python. Mỗi tệp Java thường chứa một lớp công khai. Bạn có thể sử dụng lớp đó theo hai cách:

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Nếu tệp .py này được nhập bởi các tệp .py khác, mã trong câu lệnh

python foo.py

165K27 Huy hiệu vàng250 Huy hiệu bạc298 Huy hiệu Đồng27 gold badges250 silver badges298 bronze badges

Mỗi mô -đun trong Python có một thuộc tính gọi là

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

python foo.py

# Suppose this is in some other main program.
import foo

# Suppose this is in some other main program.
import foo

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Ví dụ nhỏ để giải thích ngắn gọn.Ali Hallaji

Script test.py2 gold badges27 silver badges35 bronze badges

Chúng ta có thể thực hiện trực tiếp điều này như

Đầu ra

Bây giờ giả sử chúng ta gọi tập lệnh trên từ một tập lệnh khác:

Vì vậy, đó là những gì dòng mã này kiểm tra. Nếu đó là tệp chính (nghĩa là, B.Py) chạy mã, trong trường hợp này không (a.py là tệp chính đang chạy), thì chỉ có mã được thực thi.

Đã trả lời ngày 4 tháng 5 năm 2018 lúc 8:25May 4, 2018 at 8:25

__ Main __ có nghĩa là gì trong Python?

Nếu __ name__ chính là gì?

Nếu chính làm gì trong Python?

Main () có nghĩa là gì trong Python?