hogyan aktiválhatunk egy függvényt egy másik szkriptből


Válasz 1:

Az eredeti kódod:

def func1 (): a = 8 b = 9def func2 (x, y): z = x + y + a + b visszatér za = func2 (4,6)nyomtatás (a)

Ennek többféle módja van:

# Használja a visszatérési értékeket # Legyen egyértelmű, hogy a func2 hívása az eredményre támaszkodik a func1-re történő felhívás számadef func1 (): a = 8 b = 9 vissza a, bdef func2 (x, y, args): a, b = * args # Csomagolja ki az argumentumokból z = x + y + a + b visszatér za = func2 (4,6, args = func1 ())nyomtatás (a)# de megtehette: a = func2 (4,6, args = (9,11)) # Az adatok létrehozásához nincs szükség függvényre

vagy

# Pass funkciók: # Ebben a megoldásban Ön kifejezetten felhívja Önt # func2, amelyet meg kell hívnia a func1-nek: a func1 egy segítő funkciódef func1 (): a = 8 b = 9 vissza a, bdef func2 (x, y, func): a, b = func () z = x + y + a + b visszatér za = func2 (4,6, func1)nyomtatás (a)# Ha van egy másik függvényed, amely pár értéket generál # ezt is átadhatnád

Azt mondanám, hogy egyáltalán ne használja a Globals-t - gyors megoldásnak tűnnek, de nagyon rossz szokás.

A globális értelemben a funkció működésével kapcsolatos információkat jelent, amelyek kívül esnek a függvény argumentumain, ami sokkal nehezebbé teheti a függvény tesztelését - mivel most argumentumokat kell átadnia a függvénynek, és külön be kell állítania a releváns globális értékeket hogy tesztelje a funkcióját (ugye teszteli a funkcióit). Néha lehetetlen eltávolodni a globális adatoktól (például adatbázisok, külső webhelyek), és néha karikákon kell átugrani a kód tesztelését, ha külső adatai vannak - de ne nehezítse meg az életet még jobban .


Válasz 2:

Ez az egyes fájlokban található kódtól függ, de a válasz lényegében ugyanaz:

Függetlenül attól, hogy a függvény egy objektum metódusa, vagy egyszerűen csak meztelenül van elhelyezve a modulban, importálhatja bárhonnan, ahol deklarálták, ahová használni szeretné.

Lehetséges, hogy jó okai vannak annak, hogy nem ágyazza be a funkcióját egy objektumba, de érdemes érvényesíteni. Ésszerű érvek szólnak mellette és ellen.

Nevezzünk egy Python kódú fájlt 'modulnak'. Kényelmesen a Python modulok „szabad” névteret biztosítanak számunkra, hogy deklarációink ne kerüljenek a globális névtérbe, ahol ütközhetnek a jelenlegi vagy a jövőbeli deklarációkkal a kód más részein.

A szorosan kapcsolódó modulok könyvtárszerkezetét csomagnak nevezzük.

A nem kapcsolódó modulok könyvtárszerkezetét rendetlenségnek hívják.

Mindenesetre, ha egy foo.py nevű fájlban tárolt modul tartalmaz egy sáv nevű függvényt:

def bar (dolog1, dolog2): adja vissza a „{0}, {1}” formátumot (dolog1, dolog2)// ezt pillanatnyilag figyelmen kívül hagyja def yoda_speak (dolog1, dolog2): adja vissza a "{0}, {1}". formátumot (dolog2, dolog1)

... akkor egy másik fájlban importálhatja a funkciósávot a foo modulból:

a foo import bárbóldolog = sáv („importált”, „ez”)

... vagy importálhatja a teljes modult foo, mindegyik hozzáférhet az összes funkciójához egyszerre, ha biztosan mindet meg akarja ... mindaddig, amíg a névterükön hivatkozik rájuk (pl. Foo.function_name () )…

import fooboth_things = foo.bar ("Vigyázzon ezzel", "de a modul összes funkcióját importálhatja") yoda_speak = foo.anti_bar ("ez", "visszafelé")

Válasz 3:

Van olyan eset, amely pontosan azt teszi, amit a kérdésében leír, bár lehet, hogy nem ez a felhasználási esete. Ez egy * bezárás.

deffunkció (a): b = 2 * a def myotherfunction (c): visszatérés b * c adja vissza a myother funkciót

A myotherfunction hatékonyan megőrzi a másolatát, amely minden alkalommal felhasználásra kerül

myother = myfunction (5)eredmény = myother (5)nyomtatás (eredmény)

amely kinyomtatja: 50

A b helyi változó egy * 2 eredménye, amely esetünkben 5 volt. Ezt referenciaként kezeljük a myotherfunction-re, amely a visszatérő érték

Minden alkalommal, amikor a visszaküldött függvény meghívásra kerül, meg fogja szorozni a c argumentumot a b helyi változó értékével, amelyet referenciaként megtartottak.


Válasz 4:

Felajánlok egy másik módszert, bár az osztály, a módszerek és az attribútumok használata a helyes út.

'' ' explicit megoldás, az információ továbbítása egy változtatható módon. Valami ilyesmit használok rekurzív programokhoz, állami információkkal.'' 'import pprintdef f (d: dict) -> Nincs: print ('f függvény: argumentum feltöltése helyi változókkal') a_local_variable = 'f hozott létre' d ['a_local_variable_from_elsewhere'] = a_local_variabledef g (d: dict) -> Nincs: nyomtatás ('F FUNKCIÓ g: ARGUMENT HASZNÁLATA MÁSHOL LÉTREHOZOTT HELYI VÁLTOZÓKKAL') pprint.pprint (d)def main (): pass_variables_around = {} f (pass_variables_around) g (pass_variables_around)fő()

Válasz 5:
változó = 0def modify_global (): globális változó változó + = 1nyomtatási változó>>>> 1

A globális kulcsszó lehetővé teszi a globális változók helyi módosítását egy függvényben.

Ha egy függvényt definiálunk egy másikban, akkor az nem adja át ugyanazon nevű változók értékét. Nézd meg

9. Osztályok - Python 3.7.0 dokumentáció

A 9.1 és 9.2 szakaszok egy rövid rövid magyarázatot adnak a névadás működéséről a Pythonban.


Válasz 6:
def func1 (): globális a, b a = 8 b = 9def func2 (x, y): func1 () z = x + y + a + b visszatér za = func2 (4, 6)nyomtatás (a)# Új vagyok a pythonban, így nem vagyok biztos benne, hogy ez a legjobb megoldás. De ez az egyik megoldás.Lényegében globálissá kell tennie az a és b változókat, deklarálva őket, ha egy másik függvényben szeretné használni őket.

Válasz 7:

Nem vagyok biztos abban, hogy értem, mire gondolsz. De ha egy függvényt importál egyik fájlból a másikba, az importőr átadhat értékeket a függvénynek, a függvény pedig bármit frissíthet a saját fájljában.

Azonban, ha jól értem (és nagyon valószínű, hogy nem), akkor amit megpróbálsz megtenni, az sok esetben nagyon rossz programozási gyakorlat, a modul globálisokra támaszkodva.


Válasz 8:

Bár biztosan vannak módok, ne csináld. Ha módosítani szeretne néhány értéket egy függvény belsejében, és ezeket a módosított értékeket egy másik függvényben szeretné használni, akkor a módosítandó értékeket hívási paraméterekkel adja át az első függvénynek, és fogadja el a módosított értékeket a függvény visszatérő értékeként. Adja át a módosított értékeket a második függvénynek, és fogadja el a visszatérési értékeket.

Ez a funkcionális programozási paradigma általánosan elfogadott legjobb gyakorlata, amely megpróbálja minimalizálni (váratlanul, nem nyilvánvalóan) a függvényhívás mellékhatásait.


Válasz 9:

A megadott kód hibákat fog dobni.

Miért? A Python változó hatóköreinek működése miatt. A func () -ben deklarált a és b csak befolyásolják ezt a függvényt, ez a hatályuk.

Ha módosítani szeretné egy függvényen belüli globális változó értékeit, akkor a globális kulcsszót kell használnia:

globális xx = 123nyomtatás xfunc ()nyomtatás xdef func (): x = 124

tl; dr A kódod, ahogy van, nem fog működni.


Válasz 10:

Igen, ezt keresi. Remélem ez segít.

def c (): r = raw_input ("Kérdezzen valamit?") ... visszatér rdef p (x): ... csinálj valamit ....r = c ()p (r)