__Name__ == ÔÇť__main__ÔÇŁ: ne yapar?


Al─▒nan cevaba git


Ne yapar if __name__ == "__main__": ?

 # Threading example
import time, thread

def myfunction(string, sleeptime, lock, *args):
    while True:
        lock.acquire()
        time.sleep(sleeptime)
        lock.release()
        time.sleep(sleeptime)

if __name__ == "__main__":
    lock = thread.allocate_lock()
    thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
    thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))
 

5448









Cevap say─▒s─▒n─▒ say: 29






Python yorumlay─▒c─▒s─▒ bir kaynak dosyay─▒ okudu─čunda, iki ┼čey yapar:

  • __name__ ve gibi birka├ž ├Âzel de─či┼čken ayarlar

  • dosyada bulunan t├╝m kodu ├žal─▒┼čt─▒r─▒r.

Bunun nas─▒l ├žal─▒┼čt─▒─č─▒n─▒ ve __name__ Python komut dosyalar─▒nda her zaman g├Ârd├╝─č├╝m├╝z ├žeklerle ilgili sorunuzla nas─▒l ilgili oldu─čunu g├Ârelim.

Kod ├Ârne─či

─░├že aktarma ve komut dosyalar─▒n─▒n nas─▒l ├žal─▒┼čt─▒─č─▒n─▒ ke┼čfetmek i├žin biraz farkl─▒ bir kod ├Ârne─či kullanal─▒m. A┼ča─č─▒dakilerin ad─▒nda bir dosyada oldu─čunu varsayal─▒m foo.py .

 # Suppose this is foo.py.

print("before import")
import math

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

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

print("before __name__ guard")
if __name__ == '__main__':
    functionA()
    functionB()
print("after __name__ guard")
 

├ľzel De─či┼čkenler

Python yorumlay─▒c─▒s─▒ bir kaynak dosyay─▒ okudu─čunda, ├Ânce birka├ž ├Âzel de─či┼čken tan─▒mlar. Bu durumda, __name__ de─či┼čkeni ├Ânemsiyoruz .

Mod├╝l├╝n├╝z Ana Program Oldu─čunda

Ana program olarak mod├╝l├╝n├╝z├╝ (kaynak dosya) ├žal─▒┼čt─▒r─▒yorsan─▒z, ├Ârne─čin

 python foo.py
 

terc├╝man kodlanm─▒┼č dize atar "__main__" i├žin __name__ de─či┼čken, yani

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

Mod├╝l├╝n├╝z Ba┼čka Birinden ─░├že Aktar─▒ld─▒─č─▒nda

├ľte yandan, ba┼čka bir mod├╝l├╝n ana program oldu─čunu ve mod├╝l├╝n├╝z├╝ i├že aktard─▒─č─▒n─▒ varsayal─▒m. Bu, ana programda veya ba┼čka bir mod├╝lde ana program─▒n ithalat─▒nda b├Âyle bir ifade oldu─ču anlam─▒na gelir:

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

Bu durumda, terc├╝man mod├╝l├╝n├╝z├╝n dosya ad─▒na bakacak foo.py , s─▒yr─▒lacak .py ve bu dizgiyi mod├╝l├╝n├╝z├╝n __name__ de─či┼čkenine atayacakt─▒r.

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

Mod├╝l Kodunu ├çal─▒┼čt─▒rma

├ľzel de─či┼čkenler ayarland─▒ktan sonra, terc├╝man mod├╝ldeki t├╝m kodu, her seferinde bir ifade olarak y├╝r├╝t├╝r. Kod a├ž─▒klamas─▒yla birlikte ba┼čka bir pencereyi a├žmak isteyebilirsiniz, b├Âylece bu a├ž─▒klamay─▒ takip edebilirsiniz.

Her zaman

  1. Dizeyi yazd─▒r─▒r "before import" (t─▒rnak i┼čaretleri olmadan).

  2. math Mod├╝l├╝ y├╝kler ve denilen bir de─či┼čkene atar math . Bu, import math a┼ča─č─▒dakilerle de─či┼čtirmeye e┼čde─čerdir ( __import__ Python'da bir dize alan ve ger├žek i├že aktarmay─▒ tetikleyen d├╝┼č├╝k d├╝zeyli bir i┼člevdir):

 # Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")
 
  1. Dizeyi yazd─▒r─▒r "before functionA" .

  2. def Bir fonksiyon nesnesi yaratarak, daha sonra bu fonksiyon nesnesini ad─▒ verilen bir de─či┼čkene atayarak blo─ču ├žal─▒┼čt─▒r─▒r functionA .

  3. Dizeyi yazd─▒r─▒r "before functionB" .

  4. ─░kinci def blo─ču ├žal─▒┼čt─▒r─▒r, ba┼čka bir fonksiyon nesnesi yarat─▒r, sonra onu bir de─či┼čkene atar functionB .

  5. Dizeyi yazd─▒r─▒r "before __name__ guard" .

Sadece Mod├╝l├╝n├╝z Ana Program Oldu─čunda

  1. Mod├╝l├╝n├╝z ana programsa, o zaman __name__ ger├žekten ayarland─▒─č─▒n─▒ g├Ârecek "__main__" ve iki i┼člevi ├ža─č─▒racak, dizgileri "Function A" ve "Function B 10.0" .

Yaln─▒zca Mod├╝l├╝n├╝z Ba┼čka Birinden ─░├že Aktar─▒ld─▒─č─▒nda

  1. ( Yerine sizin mod├╝l ana program de─čil ama ba┼čka biri taraf─▒ndan ithal ise), sonra __name__ olacak "foo" de─čil "__main__" ve g├Âvdesini atlars─▒n─▒z if a├ž─▒klamada.

Her zaman

  1. Her "after __name__ guard" iki durumda da dizeyi basacakt─▒r .

├Âzet

├ľzet olarak, i┼čte iki durumda ne bas─▒lacak:

 # What gets printed if foo is the main program
before import
before functionA
before functionB
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 functionA
before functionB
before __name__ guard
after __name__ guard
 

Neden bu ┼čekilde ├žal─▒┼č─▒yor?

Neden birisinin bunu istedi─čini merak ediyor olabilirsin. Bazen .py , di─čer programlar ve / veya mod├╝ller taraf─▒ndan mod├╝l olarak kullan─▒labilecek ve ayn─▒ zamanda ana program─▒n kendisi olarak da ├žal─▒┼čt─▒r─▒labilen bir dosya yazmak istersiniz . ├ľrnekler:

  • Mod├╝l├╝n├╝z bir k├╝t├╝phanedir, ancak baz─▒ ├╝nite testleri veya bir demo ├žal─▒┼čt─▒─č─▒ bir script moduna sahip olmak istersiniz.

  • Mod├╝l├╝n├╝z yaln─▒zca ana program olarak kullan─▒l─▒r, ancak baz─▒ testlere sahiptir ve test ├žer├ževesi .py beti─činiz gibi dosyalar─▒ i├že aktararak ve ├Âzel test fonksiyonlar─▒ ├žal─▒┼čt─▒rarak ├žal─▒┼č─▒r. Senaryoyu ├žal─▒┼čt─▒rmay─▒ denemesini istemezsin ├ž├╝nk├╝ sadece mod├╝l├╝ i├že aktar─▒yor.

  • Mod├╝l├╝n├╝z ├žo─čunlukla ana program olarak kullan─▒l─▒r, ancak ayn─▒ zamanda ileri d├╝zey kullan─▒c─▒lar i├žin programc─▒ dostu bir API sa─člar.

Bu ├Ârneklerin ├Âtesinde, Python'da bir komut dosyas─▒ ├žal─▒┼čt─▒rman─▒n sadece birka├ž sihirli de─či┼čken ayarlamas─▒ ve senaryoyu i├že aktarmas─▒ zarif. Komut dosyas─▒n─▒ "├çal─▒┼čt─▒rmak", komut dosyas─▒n─▒n mod├╝l├╝n├╝ i├že aktarman─▒n bir yan etkisidir.

D├╝┼č├╝nce Yemekleri

  • Soru: Birden fazla __name__ kontrol blo─čunu alabilir miyim ? Cevap: Bunu yapmak ├žok garip, ancak dil sizi durdurmuyor.

  • A┼ča─č─▒dakilerin i├žinde oldu─čunu varsayal─▒m foo2.py . python foo2.py Komut sat─▒r─▒nda s├Âylerseniz ne olur ? Niye ya?

 # Suppose this is foo2.py.

def functionA():
    print("a1")
    from foo2 import functionB
    print("a2")
    functionB()
    print("a3")

def functionB():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    functionA()
    print("m2")
print("t2")
 
  • ┼×imdi, __name__ check-in i┼člemini kald─▒r─▒rsan─▒z ne olaca─č─▒n─▒ anlay─▒n foo3.py :
 # Suppose this is foo3.py.

def functionA():
    print("a1")
    from foo3 import functionB
    print("a2")
    functionB()
    print("a3")

def functionB():
    print("b")

print("t1")
print("m1")
functionA()
print("m2")
print("t2")
 
  • Bir komut dosyas─▒ olarak kullan─▒ld─▒─č─▒nda bu ne i┼če yarayacak? Mod├╝l olarak ne zaman al─▒n─▒r?
 # Suppose this is in foo4.py
__name__ = "__main__"

def bar():
    print("bar")

print("before __name__ guard")
if __name__ == "__main__":
    bar()
print("after __name__ guard")
 

5902







Komut dosyan─▒z Python yorumlay─▒c─▒s─▒na komut olarak ge├žirilerek ├žal─▒┼čt─▒r─▒ld─▒─č─▒nda,

 python myscript.py
 

Girinti seviyesi 0 olan t├╝m kodlar ├žal─▒┼čt─▒r─▒l─▒r. Tan─▒mlanan fonksiyonlar ve s─▒n─▒flar tan─▒mlanm─▒┼čt─▒r, ama tan─▒mlanm─▒┼č fakat kodlar─▒ndan hi├žbiri ├žal─▒┼čt─▒r─▒lmaz. Di─čer dillerden farkl─▒ olarak, main() otomatik olarak ├žal─▒┼čan bir i┼člev yoktur - main() i┼člev dolayl─▒ olarak t├╝m kodlar─▒ en ├╝st d├╝zeydedir.

Bu durumda, ├╝st seviye kod bir if bloktur. __name__ mevcut mod├╝l├╝n ismini de─čerlendiren dahili bir de─či┼čkendir. Bununla birlikte, bir mod├╝l do─črudan ├žal─▒┼čt─▒r─▒l─▒yorsa ( myscript.py yukar─▒daki gibi), __name__ bunun yerine dizeye ayarlan─▒r "__main__" . B├Âylece, komut dosyan─▒z─▒n do─črudan ├žal─▒┼čt─▒r─▒l─▒p ├žal─▒┼čt─▒r─▒lmad─▒─č─▒n─▒ veya test ederek ba┼čka bir ┼čey taraf─▒ndan i├že aktar─▒ld─▒─č─▒n─▒ test edebilirsiniz.

 if __name__ == "__main__":
    ...
 

Komut dosyan─▒z ba┼čka bir mod├╝le i├že aktar─▒l─▒yorsa, ├že┼čitli i┼člevi ve s─▒n─▒f tan─▒mlar─▒ i├že aktar─▒lacak ve ├╝st d├╝zey kodu ├žal─▒┼čt─▒r─▒lacak, ancak if yukar─▒daki f─▒kran─▒n o zamanki g├Âvdesindeki kod ko┼čulu oldu─ču gibi ├žal─▒┼čt─▒r─▒lmayacak tan─▒┼čmad─▒m. Temel bir ├Ârnek olarak, a┼ča─č─▒daki iki komut dosyas─▒n─▒ g├Âz ├Ân├╝nde bulundurun:

 # file one.py
def func():
    print("func() in one.py")

print("top-level in one.py")

if __name__ == "__main__":
    print("one.py is being run directly")
else:
    print("one.py is being imported into another module")
 
 # file two.py
import one

print("top-level in two.py")
one.func()

if __name__ == "__main__":
    print("two.py is being run directly")
else:
    print("two.py is being imported into another module")
 

┼×imdi, terc├╝man─▒ ├ža─č─▒rd─▒ysan─▒z,

 python one.py
 

├ç─▒k─▒┼č olacak

 top-level in one.py
one.py is being run directly
 

E─čer two.py ko┼čarsan─▒z:

 python two.py
 

Sen almak

 top-level in one.py
one.py is being imported into another module
top-level in two.py
func() in one.py
two.py is being run directly
 

B├Âylece, mod├╝l one y├╝klendi─činde, bunun yerine __name__ e┼čittir . "one" "__main__"


1696







__name__ De─či┼čken (imho) i├žin en basit a├ž─▒klama ┼čudur:

A┼ča─č─▒daki dosyalar─▒ olu┼čturun.

 # a.py
import b
 

ve

 # b.py
print "Hello World from %s!" % __name__

if __name__ == '__main__':
    print "Hello World again from %s!" % __name__
 

Onlar─▒ ├žal─▒┼čt─▒rmak size ┼ču ├ž─▒kt─▒lar─▒ verecektir:

 $ python a.py
Hello World from b!
 

G├Ârd├╝─č├╝n├╝z gibi, bir mod├╝l i├že aktar─▒ld─▒─č─▒nda, Python globals()['__name__'] bu mod├╝lde mod├╝l├╝n ad─▒na ayarlan─▒r . Ayr─▒ca, i├žeri aktard─▒ktan sonra mod├╝ldeki t├╝m kodlar ├žal─▒┼čt─▒r─▒lmaktad─▒r. As if i├žin deyim de─čerlendirir False bu b├Âl├╝m├╝nde y├╝r├╝t├╝lmez.

 $ python b.py
Hello World from __main__!
Hello World again from __main__!
 

G├Ârd├╝─č├╝n├╝z gibi, bir dosya y├╝r├╝t├╝ld├╝─č├╝nde Python globals()['__name__'] bu dosyay─▒ olarak ayarlar "__main__" . Bu sefer, if ifade de─čerlendirir True ve ├žal─▒┼čt─▒r─▒lmaktad─▒r.


676


2009-01-07





Ne yapar if __name__ == "__main__": ?

Temel bilgileri ana hatlar─▒yla belirtmek i├žin:

  • Genel de─či┼čken, __name__ program─▒n─▒za giri┼č noktas─▒ olan mod├╝lde '__main__' . Aksi takdirde, bu mod├╝l taraf─▒ndan ald─▒─č─▒n─▒z add─▒r.

  • Bu nedenle, if blo─čun alt─▒ndaki kod yaln─▒zca mod├╝l program─▒n─▒za giri┼č noktas─▒ysa ├žal─▒┼č─▒r.

  • Mod├╝ldeki kodun i├že aktar─▒lmakta olan kod blo─čunu ├žal─▒┼čt─▒rmadan di─čer mod├╝ller taraf─▒ndan al─▒nabilmesini sa─člar.


buna neden ihtiyac─▒m─▒z var?

Kodunuzu Geli┼čtirme ve Test Etme

Mod├╝l olarak kullan─▒lmak ├╝zere tasarlanm─▒┼č bir Python beti─či yazd─▒─č─▒n─▒z─▒ varsayal─▒m:

 def do_important():
    """This function does something very important"""
 

Bu i┼člev ├ža─čr─▒s─▒, a┼ča─č─▒ya ekleyerek mod├╝l├╝ test edebilirsiniz :

 do_important()
 

ve (komut isteminde) a┼ča─č─▒daki gibi bir ┼čeyle ├žal─▒┼čt─▒rma:

 ~$ python important.py
 

Sorun

Ancak, mod├╝l├╝ ba┼čka bir beti─če almak istiyorsan─▒z:

 import important
 

─░├že aktar─▒rken, do_important i┼člev ├ža─čr─▒l─▒r, bu nedenle i┼člev ├ža─čr─▒n─▒z─▒ muhtemelen do_important() en altta yorumlars─▒n─▒z.

 # do_important() # I must remember to uncomment to execute this!
 

Ard─▒ndan, test i┼člevi ├ža─čr─▒n─▒z─▒ yorumlay─▒p yorumlamad─▒─č─▒n─▒z─▒ hat─▒rlaman─▒z gerekir. Ve bu ekstra karma┼č─▒kl─▒k, geli┼čim s├╝recinizi daha zahmetli hale getirerek, unutman─▒z─▒n muhtemel oldu─ču anlam─▒na gelir.

En iyi yol

__name__ Python yorumlay─▒c─▒s─▒ anda olur her yerde ad alan─▒na de─či┼čken i┼čaret eder.

Al─▒nan bir mod├╝l├╝n i├žinde, o mod├╝l├╝n ad─▒.

Ancak birincil mod├╝l├╝n i├žinde (veya etkile┼čimli bir Python oturumu, yani terc├╝man─▒n Oku, De─čerlendir, Bask─▒ D├Âng├╝s├╝ veya REPL) i├žinde her ┼čeyi ├žal─▒┼čt─▒r─▒yorsunuz "__main__" .

Yani ├žal─▒┼čt─▒rmadan ├Ânce kontrol ederseniz:

 if __name__ == "__main__":
    do_important()
 

Yukar─▒dakilerle, kodunuz yaln─▒zca birincil mod├╝l olarak ├žal─▒┼čt─▒rd─▒─č─▒n─▒zda y├╝r├╝t├╝l├╝r (veya kas─▒tl─▒ olarak ba┼čka bir komut dosyas─▒ndan ├ža─č─▒r─▒r).

Daha da iyi bir yol

Bununla birlikte, bunu geli┼čtirmek i├žin Pythonic bir yol var.

Ya bu i┼č s├╝recini mod├╝l d─▒┼č─▒ndan y├╝r├╝tmek istiyorsak?

E─čer kodu koyarsak, b├Âyle bir fonksiyonda geli┼čtik├že ve test ederken egzersiz yapmak istiyoruz ve '__main__' hemen ard─▒ndan kontrollerimizi yapmak istiyoruz :

 def main():
    """business logic for when running this module as the primary one!"""
    setup()
    foo = do_important()
    bar = do_even_more_important(foo)
    for baz in bar:
        do_super_important(baz)
    teardown()

# Here's our payoff idiom!
if __name__ == '__main__':
    main()
 

┼×imdi, mod├╝l├╝ birincil mod├╝l olarak ├žal─▒┼čt─▒r─▒rsak ├žal─▒┼čacak olan mod├╝l├╝m├╝z├╝n sonu i├žin son bir i┼čleve sahibiz.

Mod├╝l ve fonksiyonlar─▒n─▒n ve s─▒n─▒flar─▒n─▒n, main fonksiyonu ├žal─▒┼čt─▒rmadan di─čer komut dosyalar─▒na al─▒nmas─▒na izin verecek ve ayr─▒ca farkl─▒ bir '__main__' mod├╝lden ├žal─▒┼čt─▒r─▒rken mod├╝l├╝n (ve fonksiyonlar─▒n─▒n ve s─▒n─▒flar─▒n─▒n) ├ža─čr─▒lmas─▒na izin verecektir.

 import important
important.main()
 

Bu deyim, Python belgelerinde ayr─▒ca __main__ mod├╝l├╝n a├ž─▒klamas─▒nda bulunabilir . Bu metin ┼č├Âyle diyor:

Bu mod├╝l, terc├╝man─▒n ana program─▒n─▒n y├╝r├╝t├╝ld├╝─č├╝ (aksi halde isimsiz) kapsam─▒ temsil eder - komutlar standart girdiden, bir komut dosyas─▒ndan veya etkile┼čimli bir komuttan okunur. Bu deyimsel ÔÇťko┼čullu scriptÔÇŁ stanza'n─▒n betik ├žal─▒┼čmas─▒na neden oldu─ču ortamd─▒r:

 if __name__ == '__main__':
    main()
 

485







if __name__ == "__main__" komut dosyas─▒, bir komut kullanarak komut sat─▒r─▒ndan (say) ├žal─▒┼čt─▒r─▒ld─▒─č─▒nda ├žal─▒┼čan k─▒s─▒md─▒r python myscript.py .


117







Ne yapar if __name__ == "__main__": ?

__name__ t├╝m isim alanlar─▒nda bulunan global bir de─či┼čken (Python'da global asl─▒nda mod├╝l d├╝zeyinde demektir ). Tipik olarak mod├╝l├╝n ad─▒d─▒r (bir str t├╝r olarak).

Ancak, tek ├Âzel durum olarak, hangi kodda Python i┼čleminde ├žal─▒┼č─▒rsan─▒z ├žal─▒┼č─▒n, mycode.py:

 python mycode.py
 

Aksi anonim genel ad de─čeri atan─▒r '__main__' onun i├žin __name__ .

B├Âylece, son sat─▒rlar dahilhttps://docs.python.org/library/__main__.html

 if __name__ == '__main__':
    main()
 
  • mycode.py beti─činizin sonunda,
  • Python i┼člemi taraf─▒ndan ├žal─▒┼čt─▒r─▒lan birincil, giri┼č noktas─▒ mod├╝l├╝ oldu─čunda,

Komut dosyan─▒z─▒n benzersiz tan─▒mlanm─▒┼č main i┼člevinin ├žal─▒┼čmas─▒na neden olur .

Bu yap─▒y─▒ kullanman─▒n bir ba┼čka yarar─▒ da: kodunuzu ba┼čka bir komut dosyas─▒nda bir mod├╝l olarak i├že aktarabilir ve ard─▒ndan program─▒n─▒z karar verirse ana i┼člevi ├žal─▒┼čt─▒rabilirsiniz:

 import mycode
# ... any amount of other code
mycode.main()
 

73







Burada, s├Âz konusu kodun mekani─či olan ÔÇťNas─▒lÔÇŁ d─▒r, ancak ÔÇťNedenÔÇŁ i anlamadan hi├žbiri anlam ifade etmedi. Bu, ├Âzellikle yeni programc─▒lar i├žin faydal─▒ olmal─▒d─▒r.

"Ab.py" dosyas─▒n─▒ al─▒n:

 def a():
    print('A function in ab file');
a()
 

Ve ikinci bir dosya "xy.py":

 import ab
def main():
    print('main function: this is where the action is')
def x():
    print ('peripheral task: might be useful in other projects')
x()
if __name__ == "__main__":
    main()
 

Bu kod asl─▒nda ne yap─▒yor?

─░dam etti─činde xy.py , sen import ab . ─░mport ifadesi, mod├╝l├╝ derhal i├že aktarma s─▒ras─▒nda ├žal─▒┼čt─▒r─▒r, bu nedenle ab i┼člemler geri kalan─▒n─▒n ├Ân├╝nde ger├žekle┼čtirilir xy . Bir kez bitti─činde ab devam eder xy .

Terc├╝man hangi komut dosyalar─▒n─▒n ├žal─▒┼čt─▒─č─▒n─▒ takip eder __name__ . Bir beti─či ├žal─▒┼čt─▒rd─▒─č─▒n─▒zda - neye ad verdi─činiz ├Ânemli de─čil - terc├╝man onu ├ža─č─▒r─▒r "__main__" , harici bir beti─či ├žal─▒┼čt─▒rd─▒ktan sonra d├Ând├╝r├╝len ana veya 'ev' beti─čini yapar.

Bu "__main__" komut dosyas─▒ndan ├ža─čr─▒lan ba┼čka bir komut dosyas─▒na dosya ad─▒ __name__ (├Ârn __name__ == "ab.py" .) Olarak atan─▒r . Bu nedenle, sat─▒r if __name__ == "__main__": , ilk olarak y├╝r├╝t├╝len 'home' komut dosyas─▒n─▒ m─▒ yorumlay─▒p ayr─▒┼čt─▒rd─▒─č─▒n─▒ m─▒ yoksa ge├žici olarak ba┼čka bir (harici) komut dosyas─▒na m─▒ bakaca─č─▒n─▒ belirlemek i├žin terc├╝man─▒n testidir. Bu, programc─▒ya do─črudan harici olarak ├ža─čr─▒l─▒rsa komut dosyas─▒n─▒n farkl─▒ davranmas─▒n─▒ sa─člama esnekli─či sa─člar.

Neler olup bitti─čini anlamak i├žin ilk ├Ânce girintisiz sat─▒rlara ve betiklerde g├Âr├╝nd├╝kleri s─▒raya odaklanarak yukar─▒daki kodu inceleyelim. Unutma - ya da def - bloklar ├ža─čr─▒lana kadar kendi ba┼člar─▒na hi├žbir ┼čey yapmazlar. Terc├╝man kendisine m─▒r─▒ldan─▒rsa ne s├Âyleyebilir:

  • Xy.py dosyas─▒n─▒ 'home' dosyas─▒ olarak a├ž─▒n; diyoruz "__main__" i├žinde __name__ de─či┼čken.
  • ─░le dosyay─▒ al─▒n ve a├ž─▒n __name__ == "ab.py" .
  • Oh, bir i┼člev. Bunu hat─▒rlayaca─č─▒m.
  • Tamam, i┼člev a() ; Bunu daha yeni ├Â─črendim. ' Ab dosyas─▒nda bir i┼člev' yazd─▒r─▒l─▒yor .
  • Dosyan─▒n sonu; geri d├Ân "__main__" !
  • Oh, bir i┼člev. Bunu hat─▒rlayaca─č─▒m.
  • Bir di─čeri.
  • ─░┼člev x() ; tamam, ' ├ževre g├Ârevi: di─čer projelerde faydal─▒ olabilir ' yaz─▒s─▒n─▒ yazd─▒r─▒n .
  • Bu nedir? Bir if a├ž─▒klama. Eh, ko┼čul yerine getirildi (de─či┼čken __name__ ayarland─▒ "__main__" ), bu y├╝zden main() fonksiyona girece─čim ve ' ana i┼člev: eylemin oldu─ču yer buras─▒ ' yazd─▒raca─č─▒m .

Alttaki iki sat─▒r: "Bu "__main__" ya da 'home' beti─či ise, ad─▒ verilen i┼člevi ├žal─▒┼čt─▒r─▒n main() ". Bu y├╝zden def main(): , komut dosyas─▒n─▒n i┼člevselli─činin ana ak─▒┼č─▒n─▒ i├žeren bir blokaj yukar─▒ g├Âreceksiniz .

Bunu neden uygulad─▒n?

─░├že aktarma ifadeleri hakk─▒nda daha ├Ânce s├Âylediklerimi hat─▒rl─▒yor musunuz? Bir mod├╝l├╝ i├že aktard─▒─č─▒n─▒zda, sadece onu 'tan─▒maz' ve daha fazla talimat beklemez - asl─▒nda beti─čin i├žindeki t├╝m ├žal─▒┼čt─▒r─▒labilir i┼člemleri ├žal─▒┼čt─▒r─▒r. B├Âylece, beti─činizin etini main() i┼čleve koymak, onu ba┼čka bir komut dosyas─▒ taraf─▒ndan i├že aktar─▒ld─▒─č─▒nda derhal ├žal─▒┼čt─▒r─▒lmamas─▒ i├žin yal─▒t─▒ml─▒ hale getirerek karantinaya al─▒r.

Yine, istisnalar olacakt─▒r, ancak yayg─▒n uygulama, main() genellikle d─▒┼čar─▒dan aranmaz. ├ľyleyse bir ┼čeyi daha merak ediyor olabilirsiniz: e─čer aram─▒yorsak main() , neden senaryoyu ├ža─č─▒r─▒yoruz? Bunun nedeni bir├žok ki┼činin komut dosyalar─▒n─▒, dosyadaki kodun geri kalan─▒ndan ba─č─▒ms─▒z olarak ├žal─▒┼čt─▒r─▒lmak ├╝zere olu┼čturulan ba─č─▒ms─▒z i┼člevlerle yap─▒land─▒rmas─▒d─▒r. Daha sonra beti─čin g├Âvdesinde ba┼čka bir yere ├ža─č─▒r─▒l─▒rlar. Bu beni buna getiriyor:

Ancak kod onsuz ├žal─▒┼č─▒r

Evet bu do─čru. Bu ayr─▒ i┼člevler , bir i┼člevin i├žinde bulunmayan bir sat─▒r i├ži komut dosyas─▒ndan ├ža─čr─▒labilir main() . Al─▒┼čm─▒┼čsan─▒z (benim gibi, programlamadaki ilk ├Â─črenim a┼čamalar─▒mda) tam olarak ihtiyac─▒n─▒z olan─▒ yapan sat─▒r i├ži komut dosyalar─▒ olu┼čturmaya al─▒┼čt─▒n─▒z ve tekrar bu i┼čleme ihtiyac─▒n─▒z olursa tekrar ├ž├Âzmeye ├žal─▒┼čacaks─▒n─▒z. kodunuz i├žin bu t├╝r bir i├ž yap─▒ya al─▒┼č─▒k de─čilsiniz, ├ž├╝nk├╝ in┼ča etmek daha karma┼č─▒k ve okumak i├žin sezgisel de─čil.

Fakat bu, muhtemelen fonksiyonlar─▒n─▒ d─▒┼čar─▒dan ├ža─č─▒rmaktan ka├ž─▒nan bir betiktir, ├ž├╝nk├╝ bunu yaparsa derhal de─či┼čkenleri hesaplamaya ve atamaya ba┼člar. Ve bir i┼člevi yeniden kullanmaya ├žal─▒┼č─▒yorsan─▒z, yeni komut dosyan─▒z─▒n eskisiyle ├želi┼čen de─či┼čkenlerin olabilece─či kadar yak─▒ndan ilgilidir.

Ba─č─▒ms─▒z i┼člevleri ay─▒r─▒rken, ├Ânceki ├žal─▒┼čman─▒z─▒ ba┼čka bir komut dosyas─▒na ├ža─č─▒rarak yeniden kullanma becerisi kazan─▒rs─▒n─▒z. ├ľrne─čin, "example.py" x() , "xy.py" den "x" i┼člevini kullanarak "xy.py" dosyas─▒n─▒ alabilir ve arayabilir . (Belki belirli bir metin dizesinin ├╝├ž├╝nc├╝ s├Âzc├╝─č├╝n├╝ b├╝y├╝k harf kullanmaktad─▒r; bir say─▒ listesinden bir NumPy dizisi olu┼čturmak ve bunlar─▒ kareler yapmak veya bir 3D y├╝zeyini azaltmak. Olas─▒l─▒klar s─▒n─▒rs─▒zd─▒r.)

(Bu vesileyle, bu soruya nihayet anlamama yard─▒mc─▒ oldu─čunu @kindall kadar bir cevap i├žeriyor -. Neden de─čil how Ne yaz─▒k ki tekrar─▒ olarak i┼čaretlenmi┼č oldu bu bir ben bir hata oldu─čunu d├╝┼č├╝n├╝yorum.)


64







Mod├╝l├╝m├╝zde ( M.py ) belli ifadeler oldu─ču zaman, ana olarak ├žal─▒┼čt─▒─č─▒nda (ithal edilmedi─činde) y├╝r├╝t├╝lmesini istiyoruz, bu ifadeleri (test durumlar─▒, bask─▒ c├╝mleleri) bu if blo─čun alt─▒na yerle┼čtirebiliriz.

Varsay─▒lan olarak (mod├╝l ana olarak ├žal─▒┼čt─▒─č─▒nda, i├že aktar─▒lmad─▒─č─▒nda) __name__ de─či┼čken olarak ayarlan─▒r "__main__" ve i├že aktar─▒ld─▒─č─▒nda __name__ de─či┼čken, b├╝y├╝k olas─▒l─▒kla mod├╝l├╝n ( 'M' ) ad─▒ olan farkl─▒ bir de─čer al─▒r . Bu, mod├╝llerin farkl─▒ de─či┼čkenlerinin bir arada ├žal─▒┼čt─▒r─▒lmas─▒nda ve belirli giri┼č ve ├ž─▒k─▒┼č ifadelerinin ayr─▒lmas─▒nda ve ayr─▒ca test durumlar─▒nda da faydal─▒d─▒r.

K─▒sacas─▒ , if __name__ == "main" mod├╝l i├že aktar─▒ld─▒─č─▒nda (belirli) kodun ├žal─▒┼čt─▒r─▒lmas─▒n─▒ ├Ânlemek i├žin bu ' ' blo─čunu kullan─▒n.


47







Basit├že s├Âylemek gerekirse __name__ , beti─čin ana mod├╝l olarak m─▒ ├žal─▒┼čt─▒r─▒ld─▒─č─▒n─▒ yoksa i├že aktar─▒lan bir mod├╝l olarak m─▒ ├žal─▒┼čt─▒r─▒ld─▒─č─▒n─▒ tan─▒mlayan her komut dosyas─▒ i├žin tan─▒mlanm─▒┼č bir de─či┼čkendir.

Yani iki senaryomuz varsa;

 #script1.py
print "Script 1's name: {}".format(__name__)
 

ve

 #script2.py
import script1
print "Script 2's name: {}".format(__name__)
 

Script1 ├žal─▒┼čt─▒rma ├ž─▒kt─▒s─▒:

 Script 1's name: __main__
 

Ve script2'yi ├žal─▒┼čt─▒rman─▒n ├ž─▒kt─▒s─▒:

 Script1's name is script1
Script 2's name: __main__
 

G├Ârd├╝─č├╝n├╝z gibi, __name__ hangi kodun 'ana' mod├╝l oldu─čunu s├Âyl├╝yor. Bu harika, ├ž├╝nk├╝ sadece kod yazabilir ve C / C ++ gibi yap─▒sal konular hakk─▒nda endi┼čelenmenize gerek kalmaz, e─čer bir dosya 'main' i┼člevini uygulamazsa, ├žal─▒┼čt─▒r─▒labilir olarak derlenemez ve e─čer o zaman bir k├╝t├╝phane olarak kullan─▒lamaz.

Diyelim ki harika bir ┼čey yapan bir Python beti─či yaz─▒yorsunuz ve ba┼čka ama├žlar i├žin faydal─▒ bir kay─▒k i┼člevi kullan─▒yorsunuz. E─čer onlar─▒ kullanmak istersem, sadece beti─čini alabilir ve program─▒n─▒z─▒ ├žal─▒┼čt─▒rmadan kullanabilirim (kodunuzun sadece if __name__ == "__main__": i├žerik i├žerisinde ├žal─▒┼čt─▒r─▒ld─▒─č─▒ d├╝┼č├╝n├╝l├╝rse ). Oysa C / C ++ 'da, bu par├žalar─▒ daha sonra dosyay─▒ i├žeren ayr─▒ bir mod├╝le b├Âlmek zorunda kalacaks─▒n─▒z. A┼ča─č─▒daki durumu hayal edin;


C de karma┼č─▒k ithalat

Oklar i├že aktarma ba─člant─▒lar─▒d─▒r. Her biri ├Ânceki mod├╝l kodunu eklemeye ├žal─▒┼čan ├╝├ž mod├╝l i├žin alt─▒ dosya (dokuz, uygulama dosyalar─▒n─▒ sayarak) ve be┼č ba─člant─▒ bulunur. Bu, ├Âzellikle bir k├╝t├╝phane olarak derlenmedik├že, bir C projesine ba┼čka bir kod eklemeyi zorla┼čt─▒r─▒r. ┼×imdi Python i├žin hayal edin:


Python'da zarif ithalat

Bir mod├╝l yaz─▒yorsunuz ve e─čer biri kodunuzu kullanmak istiyorsa, sadece i├žeri aktar─▒yorlar ve __name__ de─či┼čken program─▒n ├žal─▒┼čt─▒r─▒labilir k─▒sm─▒n─▒ kitapl─▒k b├Âl├╝m├╝nden ay─▒rmaya yard─▒mc─▒ oluyor.


38







Cevab─▒ daha soyut bir ┼čekilde inceleyelim:

Farz edelim ki bu kod x.py:

 ...
<Block A>
if __name__ == '__main__':
    <Block B>
...
 

A ve B bloklar─▒ "x.py" ├žal─▒┼čt─▒rd─▒─č─▒m─▒zda ├žal─▒┼čt─▒r─▒l─▒r.

Ancak sadece A blo─ču (B de─čil) ba┼čka bir mod├╝l ├žal─▒┼čt─▒r─▒rken ├žal─▒┼čt─▒r─▒l─▒r, ├Ârne─čin "x.py", xy'nin i├že aktar─▒ld─▒─č─▒ ve kodun oradan ├žal─▒┼čt─▒r─▒ld─▒─č─▒ ("x.py" deki bir fonksiyonun oldu─ču gibi) y.py den denir).


36







Python'u etkile┼čimli olarak ├žal─▒┼čt─▒rd─▒─č─▒n─▒zda, yerel __name__ de─či┼čkene bir de─čer atan─▒r __main__ . Benzer ┼čekilde, bir Python mod├╝l├╝n├╝ komut sat─▒r─▒ndan ba┼čka bir mod├╝le aktarmak yerine, komut sat─▒r─▒ndan y├╝r├╝tt├╝─č├╝n├╝zde, __name__ ├Âzniteli─čine mod├╝l├╝n __main__ ger├žek ad─▒ yerine bir de─čer atan─▒r . Bu sayede, __name__ ba┼čka bir program i├žin destek olarak veya komut sat─▒r─▒ndan y├╝r├╝t├╝len ana uygulama olarak kendilerinin nas─▒l kullan─▒ld─▒─č─▒n─▒ belirlemek i├žin mod├╝ller kendi de─čerlerine bakabilir . Bu nedenle, a┼ča─č─▒daki deyim Python mod├╝llerinde olduk├ža yayg─▒nd─▒r:

 if __name__ == '__main__':
    # Do something appropriate here, like calling a
    # main() function defined elsewhere in this module.
    main()
else:
    # Do nothing. This module has been imported by another
    # module that wants to make use of the functions,
    # classes and other useful bits it has defined.
 

32


2013-12-11





D├╝┼č├╝nmek:

 if __name__ == "__main__":
    main()
 

__name__ Python beti─činin ├Âzniteli─činin olup olmad─▒─č─▒n─▒ kontrol eder "__main__" . Ba┼čka bir deyi┼čle, program─▒n kendisi y├╝r├╝t├╝l├╝rse, ├Âznitelik olacakt─▒r __main__ , bu nedenle program y├╝r├╝t├╝l├╝r (bu durumda main() i┼člev).

Bununla birlikte, e─čer Python beti─činiz bir mod├╝l taraf─▒ndan kullan─▒l─▒yorsa, if ifadenin d─▒┼č─▒ndaki herhangi bir kod ├žal─▒┼čt─▒r─▒l─▒r, bu nedenle if \__name__ == "\__main__" sadece program─▒n bir mod├╝l olarak kullan─▒l─▒p kullan─▒lmad─▒─č─▒n─▒ kontrol etmek i├žin kullan─▒l─▒r ve bu nedenle kodun ├žal─▒┼čt─▒r─▒l─▒p ├žal─▒┼čt─▒r─▒lmayaca─č─▒na karar verir.


30







if __name__ == '__main__' Bununla ilgili herhangi bir ┼čeyi a├ž─▒klamadan ├Ânce , ne __name__ oldu─čunu ve ne yapt─▒─č─▒n─▒ anlamak ├Ânemlidir .

Nedir __name__ ?

__name__ bir DunderAlias - k├╝resel bir de─či┼čken olarak d├╝┼č├╝n├╝lebilir (mod├╝llerden eri┼čilebilir) ve buna benzer ┼čekilde ├žal─▒┼č─▒r global .

Bu g├Âsterildi─či gibi (├Ârne─čin yukar─▒da belirtildi─či gibi genel) bir dize type(__name__) elde edildi ( <class 'str'> ), ve her ikisi i├žin bir dahili standart Python 3 ve Python 2 alternatifler.

Nerede:

Sadece komut dosyalar─▒nda kullan─▒lamaz, ayn─▒ zamanda yorumlay─▒c─▒ ve mod├╝ller / paketlerde de bulunabilir.

Terc├╝man:

 >>> print(__name__)
__main__
>>>
 

Senaryo:

test_file.py :

 print(__name__)
 

Sonu├žlanan __main__

Mod├╝l veya paket:

somefile.py:

 def somefunction():
    print(__name__)
 

test_file.py:

 import somefile
somefile.somefunction()
 

Sonu├žlanan somefile

Bir paket veya mod├╝lde kullan─▒ld─▒─č─▒nda __name__ dosyan─▒n ad─▒n─▒ ald─▒─č─▒na dikkat edin. Ger├žek mod├╝l├╝n veya paket yolunun yolu belirtilmemi┼č, ancak buna __file__ izin veren kendi DunderAlias'─▒na sahip .

__name__ Ana dosyan─▒n (veya program─▒n) nerede , her zaman geri d├Ânece─čini __main__ ve bir mod├╝l / paket veya ba┼čka bir Python beti─čini ├žal─▒┼čt─▒ran herhangi bir ┼čey oldu─čunda, dosyan─▒n ad─▒n─▒ d├Ând├╝rd├╝─č├╝n├╝ g├Ârmelisiniz. k├Âkenli.

Uygulama:

De─či┼čken arac─▒ olmak 's de─čeri o olabilir ├╝zerine yaz─▒l─▒r olmak (ortalama "gereken" yok "olabiliriz"), bir de─čerin ├╝zerine yazmaktan __name__ okunabilirlik eksikli─či neden olur. ├ľyleyse, herhangi bir nedenle yapmay─▒n. Bir de─či┼čkene ihtiyac─▒n─▒z varsa, yeni bir de─či┼čken tan─▒mlay─▒n.

Her zaman de─čeri varsay─▒lmaktad─▒r __name__ olmak __main__ veya dosyan─▒n ad─▒. Bir kez daha bu varsay─▒lan de─čerin de─či┼čtirilmesi, daha iyi sonu├žlara yol a├žabilece─činden daha fazla karga┼čaya neden olacak ve bu da ├žizginin a┼ča─č─▒s─▒nda sorunlara neden olacakt─▒r.

├Ârnek:

 >>> __name__ = 'Horrify' # Change default from __main__
>>> if __name__ == 'Horrify': print(__name__)
...
>>> else: print('Not Horrify')
...
Horrify
>>>
 

Genel olarak if __name__ == '__main__' komut dosyalar─▒na dahil etmek iyi bir uygulama olarak kabul edilir .

┼×imdi cevap vermek i├žin if __name__ == '__main__' :

┼×imdi __name__ olaylar─▒n davran─▒┼člar─▒n─▒n netle┼čti─čini biliyoruz :

An if , verilen de─čerin do─čru olmas─▒ durumunda kod blo─čunu i├žeren bir ak─▒┼č kontrol ifadesidir. __name__ Ald─▒─č─▒n─▒ ya __main__ da al─▒nd─▒─č─▒ dosya ad─▒n─▒ alabilece─čini g├Ârd├╝k .

Bunun anlam─▒, e─čer o zaman __name__ e┼čitse __main__ , dosya ana dosya olmal─▒ ve kodda i├že aktar─▒lan bir mod├╝l ya da paket de─čil, ger├žekten ├žal─▒┼č─▒yor olmal─▒ (ya da yorumlay─▒c─▒ ise).

E─čer ger├žekten __name__ de─čerini al─▒rsa , __main__ o zaman bu kod blo─čunda ne varsa onu ├žal─▒┼čt─▒racakt─▒r.

Bu, e─čer ├žal─▒┼čan dosya ana dosya ise (ya da do─črudan terc├╝mandan ├žal─▒┼č─▒yorsan─▒z) o ko┼čulun y├╝r├╝t├╝lmesi gerekti─čini s├Âyler. Bir paket ise o zaman olmamal─▒ ve de─čer olmayacak __main__ .

Mod├╝ller:

__name__ Bir mod├╝l├╝n ad─▒n─▒ tan─▒mlamak i├žin mod├╝llerde de kullan─▒labilir.

├çe┼čitlemeler:

__name__ Burada g├Âsterece─čim baz─▒ , daha az yayg─▒n ancak yararl─▒ ┼čeyler yapmak da m├╝mk├╝nd├╝r :

Yaln─▒zca dosya bir mod├╝l veya paketse ├žal─▒┼čt─▒rma:

 if __name__ != '__main__':
    # Do some useful things 
 

Dosya ana dosya ise bir ko┼čulu ├žal─▒┼čt─▒r─▒yorsa, dosya ana dosyaysa bir ba┼čkas─▒ ├žal─▒┼čt─▒r─▒yorsa:

 if __name__ == '__main__':
    # Execute something
else:
    # Do some useful things
 

Ayr─▒ca, k├╝t├╝phaneleri ayr─▒nt─▒l─▒ bir ┼čekilde kullanmadan paketler ve mod├╝ller ├╝zerinde ├žal─▒┼čt─▒r─▒labilir yard─▒m i┼člevleri / yard─▒mc─▒ programlar─▒ sa─člamak i├žin de kullanabilirsiniz.

Ayr─▒ca, mod├╝llerin komut sat─▒r─▒ndan ana komut dosyalar─▒ olarak ├žal─▒┼čt─▒r─▒lmas─▒n─▒ da sa─člar, bu da ├žok faydal─▒ olabilir.


26







Bence cevab─▒ derinlemesine ve basit kelimelerle k─▒rmak en iyisidir:

__name__ : Python'daki her mod├╝l denilen ├Âzel bir ├Âzelli─če sahiptir __name__ . Mod├╝l├╝n ismini d├Ând├╝ren yerle┼čik bir de─či┼čkendir.

__main__ : Di─čer programlama dilleri gibi Python'da da y├╝r├╝tme giri┼č noktas─▒ vard─▒r, yani ana. '__main__' ├╝st d├╝zey kodun y├╝r├╝t├╝ld├╝─č├╝ kapsam─▒n ad─▒d─▒r . Temel olarak bir Python mod├╝l├╝n├╝ kullanman─▒n iki yolu vard─▒r: Do─črudan komut dosyas─▒ olarak ├žal─▒┼čt─▒r─▒n veya i├že aktar─▒n. Bir mod├╝l bir komut dosyas─▒ olarak ├žal─▒┼čt─▒r─▒ld─▒─č─▒nda, __name__ olarak ayarlan─▒r __main__ .

B├Âylece, __name__ ├Âzniteli─čin de─čeri __main__ , mod├╝l ana program olarak ├žal─▒┼čt─▒r─▒ld─▒─č─▒nda ayarlan─▒r . Aksi takdirde, de─čeri __name__ mod├╝l├╝n ad─▒n─▒ i├žerecek ┼čekilde ayarlan─▒r.


22







Python dosyas─▒ komut sat─▒r─▒ndan ├ža─čr─▒ld─▒─č─▒nda ├Âzel bir ┼čeydir. Bu genellikle "main ()" i┼člevini ├ža─č─▒rmak veya ├Ârne─čin komut sat─▒r─▒ arg├╝manlar─▒ gibi di─čer uygun ba┼člang─▒├ž ÔÇőÔÇőkodlar─▒n─▒ ├žal─▒┼čt─▒rmak i├žin kullan─▒l─▒r.

Birka├ž ┼čekilde yaz─▒labilir. Ba┼čka bir:

 def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()
 

Bunu ├╝retim kodunda kullanman─▒z gerekti─čini s├Âylemiyorum, ama "b├╝y├╝l├╝" bir ┼čey olmad─▒─č─▒n─▒ g├Âstermek i├žin hizmet ediyor if __name__ == '__main__' . Python dosyalar─▒nda bir ana i┼člevi ├ža─č─▒rmak i├žin iyi bir kurald─▒r.


20







Sistemin (Python yorumlay─▒c─▒s─▒) kaynak dosyalar (mod├╝ller) i├žin sa─člad─▒─č─▒ baz─▒ de─či┼čkenler vard─▒r. De─čerlerini istedi─činiz zaman alabilirsiniz, bu nedenle, __name__ de─či┼čkeni / niteli─čine odaklanal─▒m :

Python bir kaynak kod dosyas─▒ y├╝kledi─činde, i├žinde bulunan t├╝m kodu ├žal─▒┼čt─▒r─▒r. (Dosyada tan─▒mlanan t├╝m y├Ântem ve i┼člevleri ├ža─č─▒rmad─▒─č─▒n─▒, ancak bunlar─▒ tan─▒mlad─▒─č─▒n─▒ unutmay─▒n.)

Terc├╝man kaynak kod dosyas─▒n─▒ ├žal─▒┼čt─▒rmadan ├Ânce, o dosya i├žin birka├ž ├Âzel de─či┼čken tan─▒mlar; __name__ , Python'un her kaynak kod dosyas─▒ i├žin otomatik olarak tan─▒mlad─▒─č─▒ ├Âzel de─či┼čkenlerden biridir.

Python bu kaynak kod dosyas─▒n─▒ ana program olarak y├╝kl├╝yorsa (yani ├žal─▒┼čt─▒rd─▒─č─▒n─▒z dosya), bu dosyan─▒n ├Âzel __name__ de─či┼čkenini "__main__" de─čerine sahip olacak ┼čekilde ayarlar .

Bu ba┼čka bir mod├╝lden i├že aktar─▒l─▒yorsa, __name__ bu mod├╝l├╝n ad─▒na ayarlanacakt─▒r.

├ľyleyse, ├Ârne─činizdeki k─▒s─▒mda:

 if __name__ == "__main__":
   lock = thread.allocate_lock()
   thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
   thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))
 

kod blo─ču anlam─▒na gelir:

 lock = thread.allocate_lock()
thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))
 

sadece mod├╝l├╝ do─črudan ├žal─▒┼čt─▒rd─▒─č─▒n─▒zda ├žal─▒┼čt─▒r─▒l─▒r; Ba┼čka bir mod├╝l ├ža─č─▒r─▒yor / i├žeri al─▒yorsa, kod blo─ču ├žal─▒┼čmayacakt─▒r ├ž├╝nk├╝ __name__ de─čeri bu ├Ârnekte " ana " de─čerine e┼čit olmayacakt─▒r .

Umar─▒m bu yard─▒mc─▒ olur.


19







if __name__ == "__main__": temelde ├╝st d├╝zey komut dosyas─▒ ortam─▒d─▒r ve terc├╝man─▒ belirtir ('ilk ├Ânce y├╝r├╝t├╝lecek en y├╝ksek ├Ânceli─če sahibim').

'__main__' ├╝st d├╝zey kodun y├╝r├╝t├╝ld├╝─č├╝ kapsam─▒n ad─▒d─▒r. Bir mod├╝l , standart girdiden, bir komut dosyas─▒ndan veya etkile┼čimli bir komut sat─▒r─▒ndan okunurken __name__ e┼čit olarak ayarlan─▒r '__main__' .

 if __name__ == "__main__":
    # Execute only if run as a script
    main()
 

16







Bu sayfadaki cevaplar boyunca ├žok fazla okudum. E─čer bir ┼čey biliyorsan, kesin olarak bu cevaplar─▒ anlayacaks─▒n derdim, yoksa kafan kar─▒┼č─▒k.

K─▒sacas─▒, birka├ž nokta bilmeniz gerekir:

  1. import a eylem asl─▒nda "a" da ├žal─▒┼čt─▒r─▒labilecek her ┼čeyi ├žal─▒┼čt─▒r─▒yor

  2. Nokta 1 nedeniyle, i├že aktar─▒rken her ┼čeyin "a" da ├žal─▒┼čt─▒r─▒lmas─▒n─▒ istemeyebilirsiniz.

  3. 2. noktadaki sorunu ├ž├Âzmek i├žin, python bir durum kontrol├╝ koyman─▒za izin verir

  4. __name__ t├╝m .py mod├╝llerinde ├Ârt├╝k bir de─či┼čkendir; a.py al─▒nd─▒─č─▒nda, __name__ a.py mod├╝l├╝n├╝n de─čeri "a" dosya ad─▒na ayarlan─▒r; a.py do─črudan "python a.py" kullan─▒larak ├žal─▒┼čt─▒r─▒ld─▒─č─▒nda, a.py giri┼č noktas─▒ demektir __name__ , a.py mod├╝l├╝n├╝n de─čeri bir dizeye ayarlan─▒r __main__

  5. Python'un __name__ her mod├╝l i├žin de─či┼čkeni nas─▒l ayarlad─▒─č─▒ mekanizmas─▒na ba─čl─▒ olarak , 3. noktaya nas─▒l ula┼čaca─č─▒n─▒z─▒ biliyor musunuz? Cevap olduk├ža kolay, de─čil mi? Bir if ko┼čulu koyun if __name__ == "__main__": ... :; __name__ == "a" i┼člevsel ihtiyac─▒n─▒za ba─čl─▒ olarak bile koyabilirsiniz

Python'un ├Âzel oldu─ču ├Ânemli nokta 4. nokta! Gerisi sadece temel bir mant─▒kt─▒r.


15


2018-06-24





Nedeni

 if __name__ == "__main__":
    main()
 

├Âncelikle kodun do─črudan i├že aktar─▒lmas─▒ndan kaynaklanacak olan i├že aktarma kilitleme sorunlar─▒ndan ka├ž─▒nmak i├žindir . Dosyan─▒z do─črudan ├ža─čr─▒ld─▒ysa ├žal─▒┼čt─▒rmak istersiniz ( durum b├Âyledir), ancak kodunuz i├že aktar─▒lm─▒┼čsa i├že aktarma kilitleme sorunlar─▒ndan ka├ž─▒nmak i├žin ithalat├ž─▒ kodunuzu ger├žek ana mod├╝lden girmelidir.https://stackoverflow.com/questions/46326059/ main() __name__ == "__main__"

Yan etki, birden ├žok giri┼č noktas─▒n─▒ destekleyen bir metodolojide otomatik olarak oturum a├žman─▒zd─▒r. Program─▒n─▒z─▒ main() giri┼č noktas─▒ olarak ├žal─▒┼čt─▒rabilirsiniz , ancak mecbur de─čilsiniz . ─░ken setup.py beklentiden main() , di─čer ara├žlar alternatif giri┼č noktalar─▒ kullan─▒rlar. ├ľrne─čin, dosyan─▒z─▒ bir gunicorn i┼člem olarak ├žal─▒┼čt─▒rmak i├žin, a app() yerine bir i┼člev tan─▒mlad─▒n─▒z main() . Ayn─▒ ┼čekilde setup.py , gunicorn kodunuzu i├že aktar─▒r, b├Âylece i├že aktar─▒l─▒rken bir ┼čey yapmas─▒n─▒ istemeyebilirsiniz (i├že aktarma kilidi sorunu nedeniyle).


14







D├╝┼č├╝nmek:

 print __name__
 

Yukar─▒dakiler i├žin ├ž─▒kt─▒ __main__ .

 if __name__ == "__main__":
  print "direct method"
 

Yukar─▒daki ifade do─črudur ve "do─črudan y├Ântemi" yazd─▒r─▒r . Bu s─▒n─▒f─▒ ba┼čka bir s─▒n─▒fa i├že aktar─▒rlarsa, "direct method" yazm─▒yor ├ž├╝nk├╝ i├že aktar─▒l─▒rken ayarlanaca─č─▒n─▒ varsayal─▒m __name__ equal to "first model name" .


13







Dosyay─▒ i├že aktar─▒labilir bir mod├╝l kadar bir komut dosyas─▒ olarak da kullan─▒labilir duruma getirebilirsiniz .

fibo.py (adl─▒ bir mod├╝l fibo )

 # Other modules can IMPORT this MODULE to use the function fib
def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()

# This allows the file to be used as a SCRIPT
if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))
 

Referans: https://docs.python.org/3.5/tutorial/modules.html


12


2017-03-13





Bu cevap Python'u ├Â─črenen Java programc─▒lar─▒ i├žindir. Her Java dosyas─▒ genellikle bir ortak s─▒n─▒f i├žerir. Bu s─▒n─▒f─▒ iki ┼čekilde kullanabilirsiniz:

  1. S─▒n─▒f─▒ di─čer dosyalardan aray─▒n. ├ça─č─▒ran programa aktarman─▒z yeterli.

  2. S─▒nama amac─▒yla s─▒n─▒f─▒ tek ba┼č─▒na ├žal─▒┼čt─▒r─▒n.

─░kinci durumda, s─▒n─▒f, genel bir statik bo┼č bo┼čluk main () y├Ântemi i├žermelidir. Python'da bu ama├ž global olarak tan─▒mlanm─▒┼č etiket taraf─▒ndan sunulmaktad─▒r '__main__' .


9


2018-10-07





Bu .py dosyas─▒ di─čer .py dosyalar─▒ taraf─▒ndan i├že aktar─▒l─▒rsa, "if ifadesi" alt─▒ndaki kod y├╝r├╝t├╝lmez.

E─čer bu .py python this_py.py kabuk alt─▒nda ├žal─▒┼čt─▒r─▒l─▒rsa veya Windows'ta ├žift t─▒klan─▒rsa. "if ifadesi" alt─▒ndaki kod ├žal─▒┼čt─▒r─▒lacakt─▒r.

Genellikle test i├žin yaz─▒lm─▒┼čt─▒r.


5







Python'daki her mod├╝l isim olarak adland─▒r─▒lan bir ├Âzelli─če sahiptir . De─čeri ad─▒ ├Âzniteli─či 'dir ana mod├╝l do─črudan ├žal─▒┼čt─▒rd─▒─č─▒n─▒zda'. Aksi halde, ismin de─čeri mod├╝l├╝n ismidir.

K─▒saca a├ž─▒klamak i├žin k├╝├ž├╝k bir ├Ârnek.

 #Script test.py

apple = 42

def hello_world():
    print("I am inside hello_world")

if __name__ == "__main__":
    print("Value of __name__ is: ", __name__)
    print("Going to call hello_world")
    hello_world()
 

Bunu do─črudan olarak yapabiliriz.

 python test.py  
 

Çıktı

 Value of __name__ is: __main__
Going to call hello_world
I am inside hello_world
 

┼×imdi, di─čer beti─čin ├╝st├╝ndeki beti─či ├ža─č─▒rd─▒─č─▒m─▒z─▒ varsayal─▒m.

 #script external_calling.py

import test
print(test.apple)
test.hello_world()

print(test.__name__)
 

Bunu ├žal─▒┼čt─▒rd─▒─č─▒n─▒zda

 python external_calling.py
 

Çıktı

 42
I am inside hello_world
test
 

Bu y├╝zden, yukar─▒daki a├ž─▒klama kendi kendini a├ž─▒klar; e─čer testi di─čer betikten ├ža─č─▒rd─▒─č─▒n─▒zda, e─čer test.py i├žindeki d├Âng├╝ ismi ├žal─▒┼čt─▒r─▒lmazsa.


5







Bir dosya olu┼čturun, a.py :

 print(__name__) # It will print out __main__
 

__name__ __main__ bu dosyan─▒n her zaman do─črudan ana dosyan─▒n bu oldu─čunu g├Âsteren bir ├žal─▒┼čt─▒r─▒ma e┼čittir .

Ayn─▒ dizinde ba┼čka bir dosya olu┼čturun, b.py :

 import a  # Prints a
 

Ko┼č Bu yazd─▒r─▒lacakt─▒r bir , yani dosyan─▒n ad─▒n─▒ ithal edilmektedir .

Dolay─▒s─▒yla, ayn─▒ dosyan─▒n iki farkl─▒ davran─▒┼č─▒n─▒ g├Âstermek i├žin , bu yayg─▒n olarak kullan─▒lan bir numarad─▒r:

 # Code to be run when imported into another python file

if __name__ == '__main__':
    # Code to be run only when run directly
 

4







e─čer isim == ' ana ':

__name__ == '__main__': Olduk├ža s─▒k g├Âr├╝yoruz .

Bir mod├╝l├╝n ithal edilip edilmedi─čini kontrol eder.

Ba┼čka bir deyi┼čle, if blok i├žindeki kod yaln─▒zca kod do─črudan ├žal─▒┼čt─▒─č─▒nda ├žal─▒┼čt─▒r─▒l─▒r. Buraya directly ara├žlar─▒ not imported .

Mod├╝l├╝n ad─▒n─▒ basan basit bir kod kullanarak ne yapt─▒─č─▒n─▒ g├Ârelim:

 # test.py
def test():
   print('test module name=%s' %(__name__))

if __name__ == '__main__':
   print('call test()')
   test()
 

Kodu do─črudan ├žal─▒┼čt─▒r─▒rsak python test.py , mod├╝l ad─▒ __main__ :

 call test()
test module name=__main__
 

3







T├╝m cevaplar i┼člevselli─či hemen hemen a├ž─▒klad─▒. Ancak, kavram─▒n daha da temizlenmesine yard─▒mc─▒ olabilecek kullan─▒m─▒na bir ├Ârnek verece─čim.

─░ki Python dosyan─▒z oldu─čunu varsayal─▒m, a.py ve b.py. ┼×imdi, a.py b.py dosyas─▒n─▒ i├že aktar─▒r. ├ľnce "import b.py" kodunun ├žal─▒┼čt─▒r─▒ld─▒─č─▒ a.py dosyas─▒n─▒ ├žal─▒┼čt─▒r─▒yoruz. A.py kodunun geri kalan─▒ ├žal─▒┼čmadan ├Ânce, b.py dosyas─▒ndaki kodun tamamen ├žal─▒┼čmas─▒ gerekir.

B.py kodunda, b.py dosyas─▒na ├Âzg├╝ bir kod vard─▒r ve onu ├žal─▒┼čt─▒rmak i├žin b.py dosyas─▒n─▒ i├že aktarm─▒┼č ba┼čka bir dosya (b.py dosyas─▒ d─▒┼č─▒nda) istemiyoruz.

Demek bu kod sat─▒r─▒n─▒ kontrol ediyor. Kodu ├žal─▒┼čt─▒ran ana dosya (yani, b.py) ise, bu durumda (a.py ├žal─▒┼čan ana dosyad─▒r), o zaman sadece kod ├žal─▒┼čt─▒r─▒l─▒r.


3







Python yorumlay─▒c─▒s─▒ belirli bir mod├╝l├╝ ├žal─▒┼čt─▒r─▒yorsa, __name__ global de─či┼čken de─čere sahip olacakt─▒r. "__main__"

   def a():
      print("a")
  def b():
      print("b")

  if __name__ == "__main__": 

          print ("you can see me" )
          a()
  else: 

          print ("You can't see me")
          b()
 

Bu senaryoyu ├žal─▒┼čt─▒rd─▒─č─▒n─▒zda yazd─▒r─▒r beni g├Ârebilirsiniz

bir

Bu dosyay─▒ al─▒rsan─▒z, A'ya B dosyas─▒na s├Âyler ve B dosyas─▒n─▒ uygularsan─▒z A dosyas─▒nda if __name__ == "__main__" yanl─▒┼č olur, bu y├╝zden yazd─▒r─▒r Beni g├Âremezsiniz

b


3







Basit├že, dosyay─▒ C programlama dilinde main fonksiyon gibi ├žal─▒┼čt─▒rmak i├žin giri┼č noktas─▒d─▒r .


2



─░lgili yay─▒nlar


ÔÇťVerimÔÇŁ anahtar kelimesi ne i┼če yarar?

C ne yapar ??! ??! operat├Âr m├╝?

├ťnlem i┼čareti i┼člevden ├Ânce ne yapar?

'B' karakteri bir string de─či┼čmezinin ├Ân├╝nde ne yapar?

Python'da ÔÇťatÔÇŁ (@) sembol├╝ ne i┼če yarar?

Ruby'de harita (&: name) ne anlama geliyor?

'Statik' anahtar kelimesi s─▒n─▒fta ne yapar?

PHP 'var' anahtar s├Âzc├╝─č├╝ ne i┼če yarar?

Q_OBJECT makrosu ne i┼če yar─▒yor? Neden t├╝m Qt nesneleri bu makroya ihtiya├ž duyuyor?

ÔÇťGeni┼čletÔÇŁ se├žene─či grunt-Contrib-copy'te ne yapar? ├ľrneklerin t├╝m├╝ onu kullan─▒r ancak doktorlar ne yapt─▒─č─▒ hakk─▒nda hi├žbir ┼čey s├Âylemez

Etiketle ilgili di─čer sorular [python]


Denetleyicide filtre nas─▒l kullan─▒l─▒r?

Android'de% 20 saydam bir arka plan nas─▒l yap─▒l─▒r

Pandalar'daki SettingWithCopyWarning ile nas─▒l ba┼ča ├ž─▒k─▒l─▒r?

NSZombieEnabled'─▒ Xcode 4'te nas─▒l kurar─▒m?

Python's itertools.groupby () '─▒ nas─▒l kullan─▒r─▒m?

Bir tam say─▒y─▒ 2'ye b├Âlmek i├žin kullan─▒lacak daha iyi se├ženek hangisidir?

ASCII ve Unicode aras─▒ndaki fark nedir?

super () yeni stil s─▒n─▒f─▒ i├žin ÔÇťTypeError: type olmal─▒, classobj de─čilÔÇŁ olmal─▒

Kilitlenme ve livelock aras─▒ndaki fark nedir?

'Subprocess' mod├╝l├╝n├╝ zaman a┼č─▒m─▒ ile kullanma