Gyakran ismételt kérdések, python 3 kezdőknek és kezdőknek

Vannak, akik nem nagyon nyilvánvaló, szemben a kezdő Python programozók.

Miért kapok kivétel UnboundLocalError, bár a változó értéke?

Meglepőnek tűnik UnboundLocalError kap egy korábban futó kódot, amelyet hozzáadtak egy hozzárendelési művelet valahol a funkciót.

Úgy működik, de a következő kódot:

Ez vezet UnboundLocalError:

Ez azért van, mert ha rendelni egy változó kiterjedésű, ez lesz a helyi a területen, és elrejti a többi változó, az azonos nevű, a külső régiókban.

Amikor az utolsó utasítást ize rendel egy új értéket az x változó. a fordító úgy dönt, hogy egy helyi változót. Ezért, amikor a korábbi próbálkozások nyomtatni kinyomtatni inicializált változó, hiba történik.

A fenti példában, akkor érheti el a változó úgy nyilatkozott, hogy a globális:

Meg tudod csinálni egy hasonló dolog a beágyazott hatálya a kulcsszó nemlokális:

Milyen szabályok vonatkoznak a globális és lokális változók Python?

Python, változókat, amelyek a hivatkozott csak a függvényen belül tartják a globális. Ha a változó van rendelve egy új értéket bárhol a függvény törzsében, úgy véljük, hogy ez a helyi, és ha kell, akkor kell meghatároznia, hogy a globális.

Bár ez egy kicsit meglepő, első pillantásra, hogy könnyű megmagyarázni. Egyrészt, a kereslet a globális változók rendelve megakadályozza a nem kívánt mellékhatások a bárban. Másrészt, ha a globális óta kötelező minden globális kapcsolatok, akkor használja a globális egész idő alatt. Meg kellett volna bejelenteni, mint a globális minden hivatkozás a beépített funkciót vagy modult importálni alkatrészeket.

Miért névtelen függvények (lambda), a ciklusban meghatározott, a különböző értékek, vissza ugyanazt az eredményt?

Például írsz a következő kódot:

Ez ad egy listát 5 funkció, úgy x ** 2. Várható, hogy hogy hívják, visszatérnek, illetve 0, 1, 4, 9, és 16. Ugyanakkor látni fogja, hogy minden visszatér a 16:

Ez azért történik, mert x nem helyi, lambda. meghatározott külső régióban a láthatóság, és a kapott meghívás esetén - de nem, ha azt állapítjuk meg.

A ciklus végén, x = 4. ezért minden függvény visszatér 4 ** 2. azaz 16. Azt is ellenőrizni kell a változó x értékét, és nézd meg az eredményt:

Ennek elkerülése érdekében be kell tartani a változók értékét lokálisan:

Itt, n = x függvény létrehoz egy helyi változó n és kiszámítása idején meghatározása a függvény:

Ez nem csak a névtelen, valamint a szokásos funkciók.

Hogyan szervezzük megosztott a globális változók több modul?

A kanonikus módon megszervezni az ilyen hozzáférés - az, hogy hozzon létre egy külön modul (gyakran nevezik config vagy cfg). Csak add import config minden alkalmazás modul. Ebben az esetben a modul révén rendelkezésre álló globális nevet. Mivel csak egy példány a modul bármilyen változás történik a modulban mindenütt érvényesülnek. Például:

Ugyanezen okok miatt a modulokat lehet használni, mint egy alapot a végrehajtás a Singleton.

Hogyan kell használni az import?

Általános esetben nem használni modulename import *. Szennyezi a névtér a behozó. Egyesek elkerülni ezt a kifejezést, még a néhány modul, amelyek célja szerint az úgynevezett importált. Ezek a modulok, mint Tkinter és menetvágás.

Import modul elején a fájlt. Ez választ ad a kérdésre, hogy mi a modulok által megkövetelt a kódot, és hogy a modul nevét hatálya alá. Felvétel egy sort, hogy a behozatali megkönnyíti hozzáadása és eltávolítása import nyilatkozatok, de több import kevesebb helyet foglalnak el a képernyőn.

Egy jó gyakorlat, ha a behozatali modulokat az alábbi sorrendben:

standard könyvtár modulok (például, sys, os, getopt, újra)
party plug-inek (minden be van állítva, hogy a könyvtár saját csomag-) - például PIL, numpy stb
helyben létrehozott modulok

Néha meg kell tenni az import funkciója vagy osztálya problémák elkerülése érdekében a körkörös import. Gordon Mcmillan ajánlja:

Ciklikus import működik, ha mindkét modult használja egyfajta import . De nem, amikor a második modul akarja letölteni a neve az első (a modulból import neve) és az import is a külső szinten. Ez annak a ténynek köszönhető, hogy az első modul nevek még nem állnak rendelkezésre, ezért az első modul foglalt importáló második.

Ebben az esetben, ha a második modult használjuk csak egy van, az import könnyen elhelyezni ebben a funkcióban. Mire hivatkoznak, az első modul befejezte az inicializálás és a második modul végzi majd import.

Szükség lehet mozgatni import elejétől a fájlt, ha az egyik modul a platform-függő. Ebben az esetben az import az összes modul a fájl elején nem lesz lehetséges. Ebben a helyzetben egy jó megoldás az, hogy importálja a szükséges modulokat a megfelelő platform-függő kódot.

Carry az import beágyazott körök, mint például a meghatározása a funkciót csak akkor, ha probléma merül fel, mint például a ciklikus import, vagy ha úgy kívánja csökkenteni az időt a modul inicializálása.

Ez a technika akkor hasznos, ha egy csomó import nem szükséges, és attól függően, hogy a program végrehajtásra kerül. Azt is fel az import funkciót, ha bizonyos modulokat használjuk csak ezt a funkciót. Megjegyezzük, hogy betölteni a modult, az első alkalommal is drága késedelme miatt az indító modul azonban ismételt terhelés „szabad”, ezek csak pár keres a szótárakban. Még ha a modul neve eltűnt a hatály, a modul valószínűleg még sys.modules.

Miért alapértékeket megosztott objektumok között?

Ez a fajta hiba gyakori a kezdőknek. Tegyük fel, hogy a funkció:

Az első alkalommal, amikor a függvényt, mydict tartalmaz egy értéket. A második alkalommal, mydict elem 2 tartalmaz, mint amikor ize () kezdődik, mydict már tartalmazza az elem.

Gyakran előfordul, hogy várható, hogy a függvényhívás létre új objektumokat az alapértelmezett értékeket. De nem ez a helyzet. Az alapértelmezett értékek jönnek létre csak egyszer, amikor a funkció határozza meg. Ha az objektum megváltozik, mint egy szótár a példánkban következő hívás a funkció használatához a módosított objektumot.

A definíció szerint megváltoztathatatlan objektumokat (számok, karakterláncok, tuple és None), biztonságos változtatni. Változás változékony tárgyak, mint például a szótárak, listák és egyéni osztály példányok vezethet váratlan következményei.

Ezért a helyes gyakorlat az, hogy nem használja változékony tárgyak alapértékeket. Ehelyett használja a Semmi, és a függvény belsejében, ellenőrizze az érv sem, és hozzon létre egy új listát / szótárban. Például ne írj:

Azonban ez a funkció hasznos lehet. Ha van olyan funkció, amely végre hosszú ideig, gyakran alkalmazott technika - caching paraméterek és az eredmény minden függvényhívás:

Hogyan át választható vagy kulcsszó paraméterek egyik funkcióról a másikra?

Hogy ezeket a paramétereket, akkor a * és ** tervezők a listát függvényargumentum; visszatérnek a tuple helyzeti érvek és a szótár nevesített paraméterek. Akkor át őket egy másik funkció segítségével a hívás * és **:

Miért változott a listán az „y” is megváltoztatja listája „x”?

Ha írta a kódot:

akkor is meglepett, hogy a túl y is módosul x.

Két tények vezetnek a következő eredménnyel:

Változók - ez csak egy utalást egy tárgyat. y = x nem hoz létre egy példányt a lista -, egyszerűen létrehoz egy változót y. amely utal ugyanazt az objektumot, mint x.
A listák változékony.

Miután felhívta hozzáfűzni. tartalmát az objektum változott [] és [10]. Mivel x és y utalnak ugyanazt az objektumot, használja ezek közül bármelyik ad [10].

Ha használjuk a megváltoztathatatlan objektumokat:

kiderül, hogy x és y nem egyenlő, mert a számok megváltoztathatatlan, és x = x + 1 nem változtatja meg a 5-ös szám növelésével. Ehelyett létrehoz egy új objektumot 6. és adott változó x (azaz a változás, amely az objektum referenciák x). Ezt követően már 2 tárgy (6, 5) és két változók utalnak rájuk.

Egyes műveletek (például y.append (10) és a y.sort ()) változást objektum, míg mind külsőleg kapcsolatos műveletek (például y = y + [10], és rendezve (y)) hozzon létre egy új objektumot. Általában Python (és minden esetben a szabványos könyvtár), a módszer, amely megváltoztatja az objektum, visszatér Semmi. segít elkerülni a hibákat. Ezért, ha írsz

gondolt, hogy kapsz egy rendezve példányát y helyett kapsz Semmi. ez valószínűleg egy könnyen diagnosztizálható hiba.

Azonban van egy osztályban a műveletek, ahol ugyanazt a műveletet másképp viselkedik különböző típusok: kiterjesztett értékadó operátort. Például, + = felsorolja változások, de nem a száma, sorok vagy (a_list + = [1, 2, 3] egyenértékű a_list.extend ([1, 2, 3])), és megváltoztatja a listán, míg a some_tuple + = ( 1, 2, 3) és a some_int + = 1 létrehoz egy új objektumot.

Ha szeretné tudni, hogy a két változó, hogy mindig ugyanarra tárgy vagy sem, akkor a jelentése operátor. vagy beépített id függvényében.

Hogyan hozzunk létre egy magasabb rendű funkciókat?

Kétféle módon: használjon beágyazott függvény vagy felmondható tárgyakat. Például, ha a beágyazott funkciók:

Használata hívók:

Mindkét esetben

olyan funkciót nyújt, (például) az adók (10E6) == 0,3 * 10E6 + 2.

A lehívható tárgy - egy kicsit lassabb, és az eredmény egy hosszabb kódot. Megjegyzendő azonban, hogy több funkció megoszthatják aláírás keresztül öröklés:

Ez az objektum lehet fenntartani állapotban számos kihívás:

Itt inc. december alaphelyzetbe jogszabály függvényében, hogy ugyanaz a változó.

Hogyan másolni egy objektumot a Pythonban?

Sorozatok másolhatók részből áll:

Hogyan találjuk meg a rendelkezésre álló módszerek és attribútumok az objektum?

dir (x) listáját adja vissza módszereit és attribútumok.

Hogyan találhatom meg az objektum nevét?

Általánosságban elmondható, hogy bármilyen módon, mert a tárgyak nem igazán nevek. Fontos: a feladat mindig kötődik a neve az objektumot. Ez is igaz a def oktatás és az osztály.

Valószínűleg, az osztály neve is van: de, bár ez jár a két nevet, és kérte a B létrehozott példányt még mindig úgy, hogy egy osztály példánya A. Azonban ez lehetetlen megmondani, egy példány nevét vagy b. mivel mindketten kapcsolódnak az azonos értékű.

Mi elsőbbséget élveznek az üzemeltető „vessző”?

Vessző nem szereplő Python.

Mivel a vessző - nem az üzemeltető, hanem a határoló kifejezések között, a fenti példa kerül végrehajtásra, mintha be:

Ugyanez igaz az értékadó operátor (=. = +, És mások). Ezek nem szereplők, mint olyan, hanem csupán szintaktikai határoló hozzárendelési műveleteket.