Itertool függvények¶

a következő modul funkciók minden construct and return iterators. Vannak, akik végtelen hosszúságúak, ezért csak olyan funkciókkal vagy funkciókkal lehet elérni őket, amelyek csonkítják a patakot.

itertools.accumulate(iterable)¶

készítsen egy iterátort, amely halmozott összegeket ad vissza, vagy felhalmozódikmás bináris funkciók eredményei (az optionalfunc argumentumon keresztül megadva).,

Ha a func rendelkezésre áll, akkor két argumentum függvényének kell lennie. A bemeneti iterábilis elemek bármilyen típusúak lehetnekamelyet a func argumentumaként lehet elfogadni. (Például az összeadás alapértelmezett műveletével az elemek lehetnek bármilyen addabletype, beleértve a Decimal vagyFraction.)

általában a kimeneti elemek száma megegyezik a bemeneti iterábellel.Azonban, ha a kulcsszó argumentum kezdeti van megadva, theaccumulation vezet le a kezdeti érték úgy, hogy a outputhas még egy elem, mint a bemeneti iterable.,

nagyjából egyenértékű:

számos felhasználás van a func argumentumhoz. Ez lehet állítani, hogymin() egy futó minimális, max() egy futó maximális, vagyoperator.mul() egy futó termék. Az amortizációs táblázatokat kamat felhalmozásával és kifizetések alkalmazásával lehet felépíteni. First-orderrecurrence relationscan lehet modellezni azáltal, hogy a kezdeti érték az iterable segítségével onlythe felhalmozott teljes func argumentum:

lásd functools.reduce() egy hasonló függvény, amely visszaadja csak thefinal felhalmozott értéket.,

új verzió 3.2.

megváltozott a 3.3-as verzióban: Hozzáadta az opcionális func paramétert.

megváltozott a 3.8-as verzióban: Hozzáadta az opcionális kezdeti paramétert.

itertools.chain(*iterables Az egymást követő szekvenciák egyetlen szekvenciaként történő kezelésére szolgál.,Nagyjából egyenértékű:

def chain(*iterables): # chain('ABC', 'DEF') --> A B C D E F for it in iterables: for element in it: yield element

classmethodchain.from_iterable

alternatív konstruktor chain() / div>. Láncolt bemeneteket kap az asingle iterable argumentumból, amelyet lustán értékelnek. Nagyjából egyenértékű:

def from_iterable(iterables): # chain.from_iterable() --> A B C D E F for it in iterables: for element in it: yield element
itertools.combinations(iterable, r)¶

Return r hosszúságú elemek a bemeneti iterable.,

a kombinációs kapcsokat lexikográfiai sorrendben bocsátják ki a bemeneti iterábilis sorrend szerint. Tehát, ha a bemeneti iterábilis van rendezve, a kombináció tuples kerül sor sorrendben.

az elemeket pozíciójuk alapján egyedinek tekintik, nem pedig értékük alapján. Tehát, ha a bemeneti elemek egyediek, az egyes kombinációkban nem lesz ismételt érték.,

nagyjából egyenértékű:

a combinations() kódja is kifejezhető a permutations() után szűrés bejegyzéseket, ahol az elemek nemválogatott sorrendben (a pozíciójukat a bemeneti medence):

a visszaküldött tételek száma n! / r! / (n-r)! amikor 0 <= r <= nvagy nulla, ha r > n.,

itertools.combinations_with_replacement(iterable, r)¶

Return r length subsidences of elements from the input iterableallowing individual elements to be repeated more than once.

a kombinációs kapcsokat lexikográfiai sorrendben bocsátják ki a bemeneti iterábilis sorrend szerint. Tehát, ha a bemeneti iterábilis van rendezve, a kombináció tuples kerül sor sorrendben.

az elemeket pozíciójuk alapján egyedinek tekintik, nem pedig értékük alapján. Tehát, ha a bemeneti elemek egyediek, akkor a létrehozott kombinációk is egyediek lesznek.,

nagyjából egyenértékű:

a combinations_with_replacement() kódja szintén kifejezhető a product() szűrése után bejegyzések, ahol az elemeknem rendezett sorrendben vannak (a bemeneti medencében elfoglalt helyük szerint):

a visszaküldött elemek száma(n+r-1)! / r! / (n-1)!amikorn > 0.

új a 3.1-es verzióban.,

itertools.compress(data, selectors)¶

készítsen egy iterátort, amely csak azokat az adatokat szűri ki, amelyek csak a megfelelő elemet tartalmazzák a True.Leáll, ha az adatok vagy a kiválasztók iterables kimerültek.Nagyjából egyenértékű:

def compress(data, selectors): # compress('ABCDEF', ) --> A C E F return (d for d, s in zip(data, selectors) if s)

új a 3.1-es verzióban.

itertools.count(start=0, step=1)¶

készítsen egy iterátort, amely egyenletesen elosztott értékeket ad vissza a számindítással kezdve., Gyakran a map() argumentumként használják egymást követő adatpontok létrehozásához.A zip() szekvenciaszámok hozzáadásához is használható. Nagyjából egyenértékű:

def count(start=0, step=1): # count(10) --> 10 11 12 13 14 ... # count(2.5, 0.5) -> 2.5 3.0 3.5 ... n = start while True: yield n n += step

lebegőpontos számokkal történő számláláskor a jobb pontosság néha a multiplikatív kód helyettesítésével érhető el, mint például:(start + step * ifor i in count()).

megváltozott Verzió 3.1: hozzáadott lépés argumentum engedélyezett nem egész argumentumok.,

itertools.cycle(iterable)¶

készítsen egy iterátor visszatérő elemeket az iterábilisből, és mentse el az egyes elemek egy példányát.Amikor az iterable kimerült, vissza elemeket a mentett példányt. Ismétlemhatározottan. Nagyjából egyenértékű:

Megjegyzés, Az eszközkészlet ezen tagja jelentős kiegészítő tárolást igényelhet (az iterable hosszától függően).,

itertools.dropwhile(predikátum, iterable)¶

készítsen egy iterátort, amely az iterábilis elemeket leejti mindaddig, amíg a predicateis igaz; ezután minden elemet visszaad. Megjegyzés: az iterátor nem termelbármilyen kimenetet, amíg a predikátum először hamis lesz, így lehet, hogy hossza vantartózkodási idő. Nagyjából egyenértékű:

itertools.filterfalse(predikátum, iterable)¶

készítsen egy iterátort, amely csak az iterábilis elemeket szűri vissza, amelyek a predikátum False., Ha a predikátum None, adja vissza a tételeket, amelyek hamisak. Nagyjából ekvivalens:

itertools.groupby(iterable, key=None)¶

készítsen egy iterátort, amely az iterábilisből egymást követő kulcsokat és csoportokat ad vissza.A kulcs egy olyan függvény, amely minden elemhez kulcsértéket számít. Ha nincs megadva, vagy None, a kulcs alapértelmezésben egy identitás függvény, és visszatéraz elem változatlan. Általában az iterable-t már rendezni kellugyanaz a kulcsfunkció.,

agroupby() működése hasonló auniq szűrőhöz Unix-ban. Minden alkalommal, amikor a kulcsfunkció értéke megváltozik, törést vagy új csoportot hoz létre(ezért általában az adatokat ugyanazon kulcsfunkció segítségével kell rendezni). Ez a viselkedés különbözik az SQL csoportjától, amellyel a commonelements aggregálódik, függetlenül azok bemeneti sorrendjétől.

a visszaadott csoport maga is egy iterátor, amely megosztja a mögöttes iterablewith groupby()., Mivel a forrás megosztott, amikor a groupby()objektum fejlett, az előző csoport már nem látható. Tehát, ha erre az adatra később van szükség, akkor azt listaként kell tárolni:

groupby() nagyjából egyenértékű:

itertools.islice(iterable, stop)itertools.islice(iterable, start, stop)

készítsen egy iterátort, amely a kiválasztott elemeket az iterábilisból adja vissza. Ha a start nem nulla, akkor az iterábilis elemek kimaradnak a start eléréséig.,Ezután az elemek egymás után kerülnek vissza, kivéve, ha a lépés magasabb, mintegy, ami az elemek kihagyását eredményezi. Ha a stop None, akkor az iteráció addig folytatódik, amíg az iterátor kimerül, ha egyáltalán; különben megáll a megadott pozícióban. A szokásos szeleteléssel ellentétben a islice() nem támogatnegatív értékek indításhoz, leállításhoz vagy lépéshez. Lehet használni, hogy kivonat relatedfields adatokból, ahol a belső szerkezet már lapított (például amulti-line jelentés felsorolhatja a név mező minden harmadik sorban)., Nagyjából egyenértékű:

Ha a startNone, akkor az iteráció nullával kezdődik. Ha a lépés None,akkor a lépés alapértelmezés szerint egy.

itertools.permutations(iterable, r=None)¶

vissza egymást követő r hosszúságú permutációk elemek az iterable.

Ha az r nincs megadva, vagy None, akkor az r az iterábilis hosszra és az összes lehetséges teljes hosszúságú permutációra vonatkozik.

a permutációs kapcsokat lexikográfiai sorrendben bocsátják ki a bemeneti iterábilis sorrend szerint., Tehát, ha a bemeneti iterábilis van rendezve, a kombináció tuples kerül sor sorrendben.

az elemeket pozíciójuk alapján egyedinek tekintik, nem pedig értékük alapján. Tehát, ha a bemeneti elemek egyediek, az egyes permutációkban nem lesz ismételt érték.,

nagyjából egyenértékű:

a permutations() kódja szintén kifejezhető aproduct() későbbi részében, szűrve, hogy kizárja az ismétlődő elemekkel rendelkező bejegyzéseket (a bemeneti medencében azonos pozícióból):

n! / (n-r)! amikor 0 <= r <= nvagy nulla, ha r > n.

itertools.product(*iterables, repeat=1)¶

descartesian product of input iterables.,

a beágyazott hurkok ciklus, mint egy kilométer-számláló a jobb szélső elem advancingon minden iteráció. Ez a minta létrehoz egy lexikográfiai rendelési úgy, hogy haa bemenet iterables vannak rendezve, a termék tuples bocsátanak sortedorder.

Ha egy iterábilis termékét saját magával kívánja kiszámítani, adja meg az ismétlések számát az opcionális repeat kulcsszó argumentummal. Például aproduct(A, repeat=4) ugyanazt jelenti, mint a product(A, A, A, A).,

Ez a függvény nagyjából megegyezik a következő kóddal, azzal a különbséggel, hogy a tényleges implementáció nem hoz létre közbenső eredményeket a memóriában:

előtt product() fut, teljesen elfogyasztja a bemeneti iterables-eket, értékkészleteket tartva a memóriában a termékek előállításához. Ennek megfelelően csak véges bemenetek esetén hasznos.

itertools.repeat(object)¶

készítsen egy iterátort, amely újra és újra visszaadja az objektumot. Fut meghatározatlananunless a times argumentum meg van adva., Argumentumként a map() forinvariáns paraméterekhez használják a hívott függvényhez. Szintén használható zip() tocreate invariáns része egy tuple rekord.

nagyjából egyenértékű:

a gyakori használata ismétlés, hogy a kínálat egy patak állandó értékek mapor zip:

>>> list(map(pow, range(10), repeat(2)))

itertools.(függvény, iterable)¶

készítsen egy iterátort, amely kiszámítja a függvényt az iterable-ből nyert argumentumokkal., A map() helyett akkor használatos, ha az argumentumparaméterek már egyetlen iterábilisból csoportosítva vannak (az adatok “előre zippeltek”). A különbség map() és starmap() párhuzamba állítja a megkülönböztetéstween function(a,b) és function(*c)között. Nagyjából egyenértékű:

def starmap(function, iterable): # starmap(pow, ) --> 32 9 1000 for args in iterable: yield function(*args)
itertools.takewhile(predikátum, iterable)¶

készítsen egy iterátort, amely az iterábilis elemekből ad vissza elemeket, amíg a predikátum igaz., Nagyjából egyenértékű:

def takewhile(predicate, iterable): # takewhile(lambda x: x<5, ) --> 1 4 for x in iterable: if predicate(x): yield x else: break

itertools.tee(iterable, n=2)¶

vissza N független iterátorok egyetlen iterable.

a következő Python kód segít megmagyarázni, hogy mit csinál a tee (bár a tényleges megvalósítás összetettebb, és csak egyetlen underlyingFIFO sort használ).

nagyjából egyenértékű:

egyszer tee() has made a split, az eredeti iterable ne beused bárhol máshol; ellenkező esetben az iterable kap advanced without the tee objektumokat tájékoztatják.,

tee iterátorok nem threadsafe. A RuntimeError lehet beraised ha egyidejűleg iterátorok által visszaadott azonos tee()hívás, akkor is, ha az eredeti iterable threadsafe.

Ez az itertool jelentős kiegészítő tárolást igényelhet (attól függően, hogy mennyi ideiglenes adatot kell tárolni). Általában, ha egy iterátor használjaa legtöbb vagy az összes adat, mielőtt egy másik iterátor elindulna, gyorsabb alist() használata a tee()helyett.,

itertools.zip_longest(*iterables, fillvalue=None)¶

készítsen egy iterátort, amely az egyes iterablonok elemeit aggregálja. Ha az értékek egyenetlenek, akkor a hiányzó értékeket kitöltik fillvalue-val.Az iteráció addig folytatódik, amíg a leghosszabb iterábilis kimerül. Nagyjából egyenértékű:

Ha az egyik iterables potenciálisan végtelen, akkor a zip_longest()függvényt be kell csomagolni valamivel, amely korlátozza a hívások számát(például islice() vagy takewhile())., Ha nincs megadva, a fillvalue alapértelmezés szerint None.