van erre szep megoldas?
d={"a":100,"az":73,"hup":10,"abc":1,"xyz":3,"asdf":1}
for k in d:
if d[k]==1: del d[k]RuntimeError: dictionary changed size during iteration
megkerulni persze meg lehet, pl. elore lemasolni a d.keys() tombot es abban iteralni, vagy egy kulon tombbe gyujteni a torlendoket es egy masodik ciklusban csinalni a del-t...
- 892 megtekintés
Hozzászólások
d={"a":100,"az":73,"hup":10,"abc":1,"xyz":3,"asdf":1}
d2 = dict(filter(lambda item: item[1] != 1, d.items()))
print(d2)
Szerintem ennél különösebben szebb megoldás nincs.
Psszt, elárulom az IP-címemet: 192.168.0.14
- A hozzászóláshoz be kell jelentkezni
koszi, ez tenyleg szebb. ezzel csak az a baj, ha pl. egy millio elemes dictbol csak nehanyat kene kitorolni, akkor nem valami hatekony emiatt uj dict-be "atmasolni" a maradekot...
- A hozzászóláshoz be kell jelentkezni
Hat ez jogos, arra ez valoban nem lesz hatekony.
Psszt, elárulom az IP-címemet: 192.168.0.14
- A hozzászóláshoz be kell jelentkezni
Ha ilyen az arány, akkor készíts listát a törlendő kulcsokról az iteráció során, és a következő menetben töröld a lista alapján a dict elemeit.
- A hozzászóláshoz be kell jelentkezni
pontosan ezt csinalom most, csak kivancsi voltam van-e erre szebb megoldas, lehet-e az iteracio kozben torolni valahogy... C-ben lancolt listaval vagy hash tablaval megirnam siman ugy.
- A hozzászóláshoz be kell jelentkezni
Hát, írhatsz magadnak egy saját típust, ha erre van igényed :) Az kevésbé ér, hogy kézzel meg tudnám írni c-ben, mert nincs is ilyen benne, ezért kapja be a python, hogy nem azt tudja a dict megoldásuk, ami neked kell.
Cserébe nem nagyon fogod megúszni szerintem, ki kell gyűjteni a kulcsokat :(
- A hozzászóláshoz be kell jelentkezni
De ha ez baj, akkor a listából egyesével törlés még nagyobb baj, mert az is arrébb fogja másolni a lista összes hátrébb lévő elemét, minden egyes kivett elem esetén újra és újra.
- A hozzászóláshoz be kell jelentkezni
nem lista, hanem dict... ami minimum valamilyen hash tabla es/vagy lancolt lista.
- A hozzászóláshoz be kell jelentkezni
Erdemes atragni magad a kulonbozo dict init-eken, mert pl. egy comprehension majdnem biztosan hatekonyabb ennel.
- A hozzászóláshoz be kell jelentkezni
Ennyire nem ástam még bele magam a Python működésébe, a comprehension miért hatékonyabb?
Psszt, elárulom az IP-címemet: 192.168.0.14
- A hozzászóláshoz be kell jelentkezni
Mert egy lambda. Vagyis nem masolgat elotte ideiglenes teruletre, hanem kozvetlenul kerul bele elem.
Comprehension ugy nagy altalanossagban a leggyorsabb.
- A hozzászóláshoz be kell jelentkezni
Megjegyzed a pozíciót , break aztán kint delete.
zászló, zászló, szív
- A hozzászóláshoz be kell jelentkezni
Kérdés, hogy van-e pythonban tisztességes cleanup dict-ben del után. Mert nem feltétlenül "kapod vissza" azt a memóriát (fragmentáció, vagy csak simán a belső bucket-ek visszaskálázának "notimplemented" volta miatt)
- A hozzászóláshoz be kell jelentkezni
Nem biztos, hogy a memóriát akarja visszakapni :)
Egyébként bár nem túrtam soha a mélyére, de azért elég sok belső cache meg state store használja a dictet, ha elakarítod az elemre a referenciákat, akkor nem szokott elfogyni alóla mem. (Persze lehet, hogy nagyon kicsit leakel, mert csak az ojjektum takarodik el, a dict által használt bucketek vagy környékükön vmi meg nem). És ha meg elbaszod, akkor meg de :)
- A hozzászóláshoz be kell jelentkezni
Ez vsz programnyelv-fuggetlenul is egy kevesse elegans(an kinezo) dolog lesz. Legalabbis C-ben mig egy sima mezei iterator kb ilyen lehet:
for ( d = d_first; d != NULL; d = d->next )
{ do_something(d);
}
Addig a torles:
for ( d = d_first; d != NULL; )
{ item_d_t *d_next;
d_next = d->next;
if ( d->k == 1 ) delete_item(d);
d = d_next;
}
Szoval... jo kerdes...
- A hozzászóláshoz be kell jelentkezni
R-ben azért nem annyira randa:
d <- list(a = 100, az = 73, hup = 10, abc = 1, xyz = 3, asdf = 1)
d <- d[d != 1]
- A hozzászóláshoz be kell jelentkezni
Ez egy dontes kerdese, amikor tervezik a nyelvet.
Az iterator ugye olyan gyors kene, hogy legyen, amennyire lehet. Ergo, nem fer bele, hogy meg csekkelgessek, hogy "valtozott-e", es lekezeljek.
Kiveve a kifejezetten nem teljesitmenyre, hanem inkabb korrekt viselkedesre optimalizalt nyelveket/platformokat. Az R pont ilyen. Azert van ez.
- A hozzászóláshoz be kell jelentkezni
Addig a torles:
Ráadásul a fejelem törlésének a d_first-öt is módosítania kell.
De szerintem ezzel alapvetően nincs gond; az iterátor-érvényesség olyan kérdés, amivel az adatszerkezeteknél kifejezetten foglalkozni kell (... ha létezik az iterátor fogalma).
- A hozzászóláshoz be kell jelentkezni
Igen, jogos, a fenti peldabol ez kimaradt. Valojaban a delete_item egy makro ami a list headot es a torlendo elemet is megkapja mint parameter.
- A hozzászóláshoz be kell jelentkezni
Igy mondjuk? (a .keys() csak olvashatosag miatt, anelkul is jo)
>>> d={"a":100,"az":73,"hup":10,"abc":1,"xyz":3,"asdf":1}
>>> for k in list(d.keys()):
... if d[k]==1: del d[k]
...
>>> d
{'a': 100, 'az': 73, 'hup': 10, 'xyz': 3}
Ja, es mehetne list helyett tuple, kicsit eroforraskimelobb.
A strange game. The only winning move is not to play. How about a nice game of chess?
- A hozzászóláshoz be kell jelentkezni
igen ezt is csinaltam, csak nem szep...
megkerulni persze meg lehet, pl. elore lemasolni a d.keys() tombot es abban iteralni
- A hozzászóláshoz be kell jelentkezni
list(d.keys())
Itt csinalsz egy komplett masolatot a tobb millio elembol allo listarol. Raadasul egyesevel mesz vegig rajta, mikozben az eredeti adat egy tisztesseges hash volt.
Ennel rosszabb megoldast nehez talalni.
- A hozzászóláshoz be kell jelentkezni
d={"a":100,"az":73,"hup":10,"abc":1,"xyz":3,"asdf":1}
for k, v in list(d.items()):
if v == 1:
d.pop(k)
print(d)
“Windows 95/98: 32 bit extension and a graphical shell for a 16 bit patch to an 8 bit operating system originally coded for a 4 bit microprocessor, written by a 2 bit company that can't stand 1 bit of competition.”
- A hozzászóláshoz be kell jelentkezni
megkerulni persze meg lehet, pl. elore lemasolni a d.keys() tombot es abban iteralni
mondjuk te nem csak a keys-t hanem az egeszet (keys,value) lemasolod :)
bar vegulis ez meg akar lehet gyorsabb is, mint minden dict elemet key-el megcimezni!
- A hozzászóláshoz be kell jelentkezni
Nem másolom be, végigjárom. Más mód erre nincs. Nem kéne végigjárni, ha key alapján akarnál törölni a dict-ből, de te value alapján szeretnéd, arra nincs elegánsabb. Bármi más megoldás is ekvivalens lesz ezzel.
“Windows 95/98: 32 bit extension and a graphical shell for a 16 bit patch to an 8 bit operating system originally coded for a 4 bit microprocessor, written by a 2 bit company that can't stand 1 bit of competition.”
- A hozzászóláshoz be kell jelentkezni
Ha nagyon nagy a dict, és emiatt a list(d.items()) performancia problémát okoz, akkor workaround lehet még az, hogy:
for k in d:
if d[k]==1: d[k] = None
Ez persze nem túl okos dolog, ha csak az 1 értékűeket kell törölni. Ez akkor jó, ha több dologtól is függ a törlés, mert akkor egyszer helyben beállítod, hogy mit törölnél, utána pedig a feldolgozás során átléped, ami már elszórva nem egy nagy döccenést okoz, plusz amikor a programod idle -ben fut, akkor nyomhatsz egy tisztítást a d -re.
A legjobb módszer szerintem erősen függ attól, hogy mekkora a d, és hogy mekkora részét teszik ki az 1-es értékű elemek, mert ha sokat, akkor például egy új dict gyártása filterrel jó ötlet, míg ha elenyésző, akkor nem jó irány.
- A hozzászóláshoz be kell jelentkezni
Jatszottam egy picit a problemaval. Az eredeti felvetesben meg nem szerepelt az, hogy millios a dict, ezert is irtam a listaba mentest (meg mert arra a legegyszerubb atirni az eredeti, nem mukodot). Termeszetesen ha tul nagy a dict, akkor az lesz a legjobb, ha kulon kigyujtjuk a rossz elemek kulcsait, es utana ezeket toroljuk.
Megirtam az otletek alapjan parat, amihez nem volt kod, a tobbit meg bemasoltam. A kodokat tobbszor lefuttatva nagyon mas szamokat kaptam (a seedet nem akartam fixalni, nem hiszem, hogy szamitananak a konkret szamok), de a torloalgoritmusok idejenek a sorrendje nagyjabol fix volt (kiveve persze, ahol kicsi volt a kulonbseg).
Az eredmenyek:
1_000_000 elem, 1% torlendovel (elsonel csak 10 teszt atlaga volt, utana 100):
306.48188 ms nullptr_lambda
226.72707 ms hory_comprehension
164.18201 ms YleGreg_none
178.61049 ms dumb_for_with_list
180.24219 ms dumb_for_with_tuple
162.95704 ms Raynes_pop
42.37052 ms collect_and_delete_tuple
40.80489 ms collect_and_delete_list_comprehension
innentol 100 teszt atlaga:
308.761951 ms nullptr_lambda
228.882706 ms hory_comprehension
181.400935 ms YleGreg_none
180.352806 ms dumb_for_with_list
180.965113 ms dumb_for_with_tuple
169.337919 ms Raynes_pop
43.717338 ms collect_and_delete_tuple
55.782222 ms collect_and_delete_list_comprehension
299.539108 ms nullptr_lambda
231.145582 ms hory_comprehension
164.153661 ms YleGreg_none
179.763108 ms dumb_for_with_list
185.511865 ms dumb_for_with_tuple
186.877396 ms Raynes_pop
50.006395 ms collect_and_delete_tuple
45.016147 ms collect_and_delete_list_comprehension
1_000_000 elem, 20% torlendo, 100 teszt:
280.340851 ms nullptr_lambda
217.177389 ms hory_comprehension
172.452924 ms YleGreg_none
209.975946 ms dumb_for_with_list
187.794945 ms dumb_for_with_tuple
210.398768 ms Raynes_pop
95.312606 ms collect_and_delete_tuple
89.21088 ms collect_and_delete_list_comprehension
255.113054 ms nullptr_lambda
235.54483 ms hory_comprehension
179.64522 ms YleGreg_none
190.935718 ms dumb_for_with_list
191.051743 ms dumb_for_with_tuple
212.003838 ms Raynes_pop
131.213676 ms collect_and_delete_tuple
106.744159 ms collect_and_delete_list_comprehension
1000-es dict, 1% torlendo, de 100 helyett 100_000 teszt:
0.14031875 ms nullptr_lambda
0.098073557 ms hory_comprehension
0.057327860999999994 ms YleGreg_none
0.055978737 ms dumb_for_with_list
0.053868858 ms dumb_for_with_tuple
0.061609896 ms Raynes_pop
0.038435756 ms collect_and_delete_tuple
0.039400389 ms collect_and_delete_list_comprehension
A kod, ha masnak is lenne kedve hozza:
from random import randint, choice
from time import perf_counter_ns
MAX_NUM = 1_000_000_000
DICT_SIZE = 1_000_000
PERCENTAGE = 1
# PERCENTAGE = 20
TEST_COUNT = 100
# DICT_SIZE = 1_000
# PERCENTAGE = 1
# TEST_COUNT = 100_000
def prepare_dict(n: int, percentage_of_1s) -> dict:
d = {randint(2, MAX_NUM): randint(2, MAX_NUM) for _ in range(n)}
number_of_1s_needed = (n * percentage_of_1s) // 100
keys = tuple(d.keys())
while number_of_1s_needed > 0:
key = choice(keys)
if d[key] != 1:
d[key] = 1
number_of_1s_needed -= 1
return d
def runner(func: callable, d: dict) -> None:
cumulated_time = 0
for _ in range(TEST_COUNT):
new_dict = dict(d)
start_time = perf_counter_ns()
func(new_dict)
end_time = perf_counter_ns()
cumulated_time += end_time - start_time
print(f"{cumulated_time / TEST_COUNT / 1_000_000.0} ms {func.__name__}")
def dumb_for_with_list(d: dict) -> dict:
for k in list(d.keys()):
if d[k] == 1:
del d[k]
return d
def dumb_for_with_tuple(d: dict) -> dict:
for k in tuple(d.keys()):
if d[k] == 1:
del d[k]
return d
def nullptr_lambda(d: dict) -> dict:
return dict(filter(lambda item: item[1] != 1, d.items()))
def hory_comprehension(d: dict) -> dict:
return {k: v for k, v in d.items() if v != 1}
def Raynes_pop(d: dict) -> dict:
for k, v in list(d.items()):
if v == 1:
d.pop(k)
return d
def YleGreg_none(d: dict) -> dict:
for k in d:
if d[k] == 1:
d[k] = None
return d
def collect_and_delete_list_comprehension(d: dict) -> dict:
for k in [k for k, v in d.items() if v == 1]:
del d[k]
return d
def collect_and_delete_tuple(d: dict) -> dict:
for k in tuple(k for k, v in d.items() if v == 1):
del d[k]
return d
def main():
d = prepare_dict(DICT_SIZE, PERCENTAGE)
runner(nullptr_lambda, d)
runner(hory_comprehension, d)
runner(YleGreg_none, d)
runner(dumb_for_with_list, d)
runner(dumb_for_with_tuple, d)
runner(Raynes_pop, d)
runner(collect_and_delete_tuple, d)
runner(collect_and_delete_list_comprehension, d)
if __name__ == '__main__':
main()
Meglepo, de annyira nem rossz a kulcsokat listaba/tuple-be gyujtos megoldas sem. A dict 0-rol felepitese viszont erezhetoen lassabb, fuggetlenul a filter+lambda, vagy dict comprehension megoldastol, bar utobbi picit gyorsabb annal.
szerk: A decoratorokat ismerem, viszont nem akartam bonyolitani, meg nem szerettem volna beszolasokat, hogy biztos amiatt lassabb egyik vagy masik megoldas.
A strange game. The only winning move is not to play. How about a nice game of chess?
- A hozzászóláshoz be kell jelentkezni
Ez tok jo! :-)
Viszont az en otletemet szeretnem diszkvalifikalni, mert az nem torol, csak megjelol, ergo nem ad olyan teljeskoru megoldast, mint a tobbi.
- A hozzászóláshoz be kell jelentkezni
Alkalmazastol fuggoen teljesen legitim az is. Kicsit olyasmi, mint algoritmuselmeletben az amortizalt idoigeny, igy latszik, hogy a jeloles ideje mennyi, es ha lenne masik fele, azzal egyutt legalabb mennyi ido lenne a teljes, ad egy also becslest. (a valasz pedig, hogy kb. annyi, mint a tobbi ciklusos megoldase)
Aki nem ismerne: ha van mondjuk egy adatszerkezetunk, amibol 1 egyseg a torles, de n torles utan igenyel n egysegnyi adminisztraciot, "kiatlagoljuk", es azt mondjuk, hogy a peak-ektol eltekintve 2 egysegbe kerul a torles. Worst case-ben nem lesz jo, de osszessegeben nagy atlagban igen.
A strange game. The only winning move is not to play. How about a nice game of chess?
- A hozzászóláshoz be kell jelentkezni
Plusz egyedik megoldás, hogy ezt a szegény d dict -et nem natívan kezelem, hanem berakom egy class -ba, és az összes feltöltési művelet során ellenőrzöm a kapott értéket, és ha az 1, akkor nem teszek semmit.
Ez nem túlzottan elegáns, viszont mivel a nagy méretű adatszerkezetekre az életciklusuk alatt többnyire több olvasás érkezik, mint írás, ezért hatékonyabb lehet, mint időről-időre végigvizsgálni az elemeit, hogy hátha szemetet tartalmaz.
- A hozzászóláshoz be kell jelentkezni
Igen, ez teljesen jo felvetes. Viszont nem tudjuk az eredeti feladatot, konnyen lehet, hogy az 1 nem mindig 1, hanem csak utolag derul ki. Intervallum is lehet, vagy valamilyen bonyolultabb logika eredmenye. Arpi gondolom nem akart teljes kodot bemasolni, hanem minimalis reprodukalhato kodot irt ide - nagyon helyesen. Erre az, hogy 1 vagy nem 1, boven eleg.
A strange game. The only winning move is not to play. How about a nice game of chess?
- A hozzászóláshoz be kell jelentkezni
> Arpi gondolom nem akart teljes kodot bemasolni, hanem minimalis reprodukalhato kodot irt ide - nagyon helyesen
meg igazabol nem is egy konkret problema megoldasa miatt irtam, csak ugy eszembe jutott ez. az evek soran sokszor, sok helyen elojott mar, hogy nem lehet a dict-bol takaritani iteracio kozben, csak kerulo megoldasokkal. rengeteg peldat tudnek irni, a szavak szamolgatasa csak egy volt a sok kozul. persze az is igaz hogy optimalizalashoz celszeru ismerni az adott problemat, a dict meretet, a torles feltetelet stb.
- A hozzászóláshoz be kell jelentkezni
ez igy biztos nem jo! a fenti pelda pl. onnan jott, hogy sok 100 gb txt-t olvasok be, szavakra bontom (itt azert eleg sok trukkozes van, de az most mind1) es a szavakat szamlalom a dict-ben. idonkent (mondjuk par millio szavankent), hogy ne nojjon vegtelen mereture a dict, a ritkakat (limit alatti ertek, pl az 1-esek) kidobalom, mert azok vszinu nem valos szavak, hanem valami eliras, nev, tipuskod stb. de amugy +=1-ezem mindig az erteket, tehat minden elem 1-el kezdodik, majd ha tobbszor is elofordul akkor idovel nagyobb lesz a szam. ha 1-nel kikukaznam akkor egy ures tombot kapnek :)
a masik ahol ez a dict takaritas kellett volna, a sessionok kipucolasa. pl. radius vagy ssl adatforgalom passziv elemzese (nflog, pcap), pakolgatom ip+port alapjan egy dictbe az onnan jovo infokat, de ha mar egy jo ideje nem jott semmi es vege se volt (accept/reject ill establisted) akkor kukazom az egeszet (nyilvan idokozben leszakadt a kliens aki kezdemeneyzte).
- A hozzászóláshoz be kell jelentkezni
miert? baromi lassu lenne egy dict-hez kepest...
- A hozzászóláshoz be kell jelentkezni
Ez lassúság nem releváns, az egész Python egy baromi lassú nyelv. Ha gyors kód kell, ne ezen a nyelven írd.
“Windows 95/98: 32 bit extension and a graphical shell for a 16 bit patch to an 8 bit operating system originally coded for a 4 bit microprocessor, written by a 2 bit company that can't stand 1 bit of competition.”
- A hozzászóláshoz be kell jelentkezni
> Python egy baromi lassú nyelv
pypy-vel (JIT) nem annyira, alig lassabb a c-el. es 1000x konnyebb benne ilyen string manipualcios dolgokat vagy hashelest csinalni.
viszont a redis emlekeim szerint egy tcp/ip-n kommunikalo szerver kb mint egy buta mysql/nosql, nem hinnem hogy egy dict kivaltasara opcio lenne.
- A hozzászóláshoz be kell jelentkezni
Kicsi modositassal jo az, amit irt a modositott problemara is (kis plusz memoria felaldozasaval):
Csinalsz egy wrappert a dict kore, ez idaig oke, es fogsz egy set-et is, amiben szerepel az eddig 1 alkalommal szerepeltek szama. Beszuraskor ugyanugy noveled a dict-edet, es a novelt ertek alapjan az 1-szer szereplok set-jet is adminisztralod: ha a dict-beli novelt ertek 1, akkor beteszed ebbe, ha 2, akkor kiveszed, ha mas, akkor nem foglalkozol vele. Idonkent a set elemein vegigmesz, torlod az alapjan a dict key-eit, aztan az egesz set-et kukazod. A leirasod alapjan nem lesz a set merete nagy menet kozben, ugyhogy nem lesz tul nagy a plusz memoriahasznalat. Illetve a sokszor elofordulok lesznek a dict-edben tulsulyban, emiatt a set-edhez hozza sem kell nyulnod a legtobb szonal, kicsi marad az idoigenyben is az overhead.
A strange game. The only winning move is not to play. How about a nice game of chess?
- A hozzászóláshoz be kell jelentkezni
nem rossz otlet! persze ez csak addig mukodik amig csak az 1x elofordulokat akarom kukazni, nem mondjuk az 5-nel kevesebbet.
nem kell amugy dictet wrapperelni, eleg ha a szamolast atirom erre:
try:
words_dict[key]+=1 # az esetek nagy reszeben ugyis ez fut le
except:
if key in words_set:
words_dict[key]=2
words_set.remove(key) # de ez se kell igazabol!
else: words_set.add(key)
es akkor eleg idonkent a set-et kukazni...
vagy perverzebben:
try:
words_dict[key]+=1 # az esetek nagy reszeben ugyis ez fut le
except:
try:
words_set.remove(key)
words_dict[key]=2
except: words_set.add(key)
- A hozzászóláshoz be kell jelentkezni
Ha nyomsz egy ctrl-c-t a megfelelo pillanatban, mert az exceptnel hianyzik a tipus, az gond. De ha tudod, hogy a legvegen az utolso lepeskent ugyis kukazod az 1-eseket, akkor persze nem kell oket a dict-ben is tarolni, szoval az elgondolas jo.
szerk: Kozben modositottad, mar csak az onmagaban all except-ekbe tudnek belekotni, tobbit kiszedtem. :D
A strange game. The only winning move is not to play. How about a nice game of chess?
- A hozzászóláshoz be kell jelentkezni
> az utolso lepeskent ugyis kukazod az 1-eseket
nyilvan, miert pont a vegen oriznem meg ha menet kozbe is folyton kukaztam oket? :)
sot a vegen lehet hogy az 5 alattiakat mind kukazom... (ha mar igy kozbe nem lehet)
pontosabban a vegen sorba rendezem es a top 1M vagy 250k word marad csak meg...
> az exceptnel hianyzik a tipus
PoC kodnal ilyen aprosagokkal nem foglalkozunk :) (tudom, igy nem muxik a ctrl+c)
amugy se tudtam sose megjegyezni az exceptionok neveit... (tudom hasznaljak IDE-t vagy AI-t, es ne mcedit-et :))
- A hozzászóláshoz be kell jelentkezni
Ilyesmire gondolok:
class DictForOne:
# https://en.wikipedia.org/wiki/Dinner_for_One
def __init__(self):
self.words: dict = {}
self.singular_items: set = set()
def __str__(self) -> str:
return str(self.words)
def get_key(self, key) -> int:
return self.words.get(key, 0)
def add_one(self, key) -> int:
count = self.get_key(key)
count += 1
self.words[key] = count
if count == 1:
self.singular_items.add(key)
elif count == 2:
self.singular_items.remove(key)
return count
def cleanup(self):
for key in self.singular_items:
del self.words[key]
self.singular_items = set()
# todo: __iter__, __next__, __getitem__, __setitem__, etc...
# ezeket majd megirod, ha szukseges
import re
text = '''
Ég a napmelegtől a kopár szík sarja,
Tikkadt szöcskenyájak legelésznek rajta;
Nincs egy árva fűszál a tors közt kelőben,
Nincs tenyérnyi zöld hely nagy határ mezőben.
Boglyák hűvösében tíz-tizenkét szolga
Hortyog, mintha legjobb rendin menne dolga;
Hej, pedig üresen, vagy félig rakottan,
Nagy szénás szekerek álldogálnak ottan.
Ösztövér kutágas, hórihorgas gémmel
Mélyen néz a kútba s benne vizet kémel:
Óriás szunyognak képzelné valaki,
Mely az öreg földnek vérit most szíja ki.
Válunál az ökrök szomjasan delelnek,
Bőgölyök hadával háborúra kelnek:
De felült Lackó a béresek nyakára,
Nincs, ki vizet merjen hosszu csatornára.
Egy, csak egy legény van talpon a vidéken,
Meddig a szem ellát puszta földön, égen;
Szörnyü vendégoldal reng araszos vállán,
Pedig még legénytoll sem pehelyzik állán.
Széles országútra messze, messze bámul,
Mintha más mezőkre vágyna e határrul;
Azt hinné az ember: élő tilalomfa,
Ütve ,általútnál’ egy csekély halomba.
Szép öcsém, miért állsz ott a nap tüzében?
Ládd, a többi horkol boglya hűvösében;
Nyelvel a kuvasz is földre hengeredve,
A világért sincs most egerészni kedve:
Vagy sohasem láttál olyan forgó szelet,
Mint az, aki mindjárt megbirkózik veled,
És az útat nyalja sebesen haladva,
Mintha füstokádó nagy kémény szaladna?
Nem is, nem is azt a forgószelet nézi,
Mely a hamvas útat véges-végig méri:
Túl a tornyon, melyet porbul rakott a szél,
Büszke fegyver csillog, büszke hadsereg kél.
És amint sereg kél szürke por ködéből,
Úgy kel a sohajtás a fiú szivéből;
Aztán csak néz, csak néz előre hajolva,
Mintha szive-lelke a szemében volna.
„Szép magyar leventék, aranyos vitézek!
Jaj be keservesen, jaj be búsan nézlek.
Merre, meddig mentek? Harcra? Háborúba?
Hírvirágot szedni gyöngyös koszorúba?
Mentek-é tatárra? mentek-é törökre,
Nekik jóéjtszakát mondani örökre?
Hej! ha én is, én is köztetek mehetnék,
Szép magyar vitézek, aranyos leventék!”
Ilyenforma Toldi Miklós gondolatja,
Mely sovárgó lelkét mélyen szántogatja;
S amint fő magában, amint gondolkodik,
Szíve búbánatban összefacsarodik.
Mert vitéz volt apja; György is, álnok bátyja,
A királyfi mellett nőtt fel, mint barátja;
S míg ő béresekkel gyüjt, kaszál egy sorban,
Gőgösen henyél az a királyudvarban.
Itt van immár a had, Laczfi nádor hada,
Itt kevély hadával Laczfi Endre maga;
Délcegen megűli sárga paripáját,
Sok nehéz aranyhím terheli ruháját;
És utána nyalka, kolcsagos legények,
Tombolván alattok cifra nyergü mének:
Nézi Miklós, nézi, s dehogy veszi észbe,
Hogy a szeme is fáj az erős nézésbe.
„Hé, paraszt! melyik út megyen itt Budára?”
Kérdi Laczfi hetykén, csak amúgy félvállra;
De Toldinak a szó szivébe nyilallik,
És olyat döbben rá, hogy kivűl is hallik.
„Hm, paraszt én!” emígy füstölög magában,
„Hát ki volna úr más széles e határban?
Toldi György talán, a rókalelkü bátya,
Ki Lajos királynál fenn a tányért váltja?
Én paraszt? én?” - Amit még e szóhoz gondolt,
Toldi Györgyre szörnyü nagy káromkodás volt.
Azzal a nehéz fát könnyeden forgatja,
Mint csekély botocskát, véginél ragadja;
Hosszan, egyenesen tartja félkezével,
Mutatván az utat, hol Budára tér el,
S mintha vassá volna karja, maga válva,
Még csak meg se rezzen a kinyujtott szálfa.
Nádorispán látja Toldit a nagy fával,
És elámul rajta mind egész hadával.
„Ember ez magáért” Laczfi mond „akárki;
Nos fiúk, birokra, hadd lássuk, ki áll ki?
Vagy ki tartja úgy fel azt a hitvány rúdat,
Amellyel mutatja e suhanc az útat?”
Szégyen és gyalázat: zúg, morog mindenki,
Egy paraszt fiúval még sem áll ki senki!
De ki vína bajt az égiháborúval,
Szélveszes, zimankós, viharos borúval?
És ki vína Isten tüzes haragjával,
Hosszu, kacskaringós, sistergő nyilával?
Mert csak az kössön ki Toldival, ha drága
S nem megunt előtte Isten szép világa;
Jaj-keserves annak, aki jut kezébe,
Meghalt anyjának is visszarí ölébe.
Elvonul a hadnép hosszu tömött sorban,
Toldiról beszélnek az egész táborban;
Mindenik mond néki nyájasat vagy szépet,
Mindenik derít rá egy mosolygó képet;
Egyik így szól: „Bajtárs! mért nem jősz csatára?
Ily legénynek, mint te, ott van ám nagy ára.”
Másik szánva mondja: „Szép öcsém, be nagy kár,
Hogy apád paraszt volt s te is az maradtál.”
Elvonúl a tábor, csillapul morajja:
Ezt a szél elhordta, azt a por takarja;
Toldi meg nagybúsan hazafelé ballag,
Vaskos lábnyomától messze reng a parlag;
Mint komor bikáé, olyan a járása,
Mint a barna éjfél, szeme pillantása,
Mint a sértett vadkan, fú veszett dühében,
Csaknem összeroppan a rúd vas kezében.
'''
if __name__ == "__main__":
word_dict = DictForOne()
for word in re.findall(r'[a-zA-ZöüóőúéáűíÖÜÓŐÚÉÁŰÍ]+', text):
word = word.lower()
word_dict.add_one(word)
print(word_dict)
word_dict.cleanup()
print(word_dict)
A strange game. The only winning move is not to play. How about a nice game of chess?
- A hozzászóláshoz be kell jelentkezni
Faja. :)
Itt imho érdemes volna memet is nézni esetleg, csak azt kevésbé trivi.
- A hozzászóláshoz be kell jelentkezni