Ebben a posztban a listáinkat tesszük többdimenzióssá.
Ez egy egydimenziós lista: ['mert', 'olyan', 'mint', 'egy'] vonal, azaz csak egy kiterjedése van, mégpedig a hosszúsága (tudod: len()).
[['Ha', 'egy', 'lista'], ['egy', 'táblázatra', 'hasonlít'], ['akkor', 'kétdimenziósnak', 'hívjuk.']]
Nézd meg jól eszt a listát: hány eleme van? Kilenc?? Nem, csak három, de mindegyik egy újabb lista, megint csak három-három elemmel. Ez egy kétdimenziós lista, amit Pythonban gyakran neveznek listák listájának (angolul: list of lists). Persze nem kell három sorban írni. A kódban szabad, mert esetleg úgy neked olvashatóbb, de ha ki akarod print()-elni, akkor bizony egy sorba kerül, így:
[['Ha', 'egy', 'lista'], ['egy', 'táblázatra', 'hasonlít'], ['akkor', 'kétdimenziósnak', 'hívjuk.']].
Az egyes elemek elérésére ilyenkor két indexet használunk. Ha a fenti lista neve a kreativitás esszenciájaként “lista”, akkor “táblázatra” szó a lista[1][1], azaz a második elem második eleme.
Na, akkor videózzunk:
A split() tagfüggvény
A karakterlánc adattípus tagfüggvénye, és arra jó, hogy az általunk megadott határolókarakternél szétszedi a karakterláncot listává. Ha nem adunk meg semmit, akkor a whitespace karaktereknél (emléxel: szóköz, sorvége, tabulátor) hasít, de különben nézd meg magadnak.
Feladatok
A következő feladatok megoldásánál használd ezt a fájlt (az oszlopok jelentése: név, poszt, játszott meccsek száma, rúgott gólok száma):
Aladar hatved 8 2 Bela hatved 10 2 Csaba csatar 7 10 Dezso csatar 8 11 Elemer kozeppalyas 9 3 Ferenc kozeppalyas 9 3 Geza csatar 9 4
F0029a: Írd ki a csapattagok nevet egy sorba, vesszővel elválasztva! Adj megoldást úgy is, hogy tárolod az adatokat egy 2D listában, meg úgy is, hogy nem tárolod őket, csak olvasol egy sort és már írsz is! (Megoldás itt.)
F0029b: Áruld el, hogy hány csatár adatai vannak tárolva a fájlban! (Megoldás itt.)
F0029c: Az előző megoldásodat alakítsd át úgy, hogy használj függvényt, és a függvény akármelyik poszton játszó játékosokat meg tudja számolni. A függvény két paramétere a 2D lista, illetve a megszámolandó játékosok posztja. (Megoldás itt.)
F0029d: Ki és milyen poszton rúgta a legkevesebb gólt? Tipp: határozd meg, hogy mennyi a legkevesebb gól, aztán határozd meg, hogy ki rúgott ennyit. (Megoldás itt.)
F0029e: Van-e olyan, aki legalább 10 meccset játszott?
F0029f: Hány gólt rúgtak a játékosok átlagosan? Tipp: számold össze a gólokat, majd a kapott számot oszd el a focisták lista hosszával!
F0029g: Hány gólt rúgtak az egyes posztokon lévő játékosok átlagosan?
Pythonidomár 
Kedves raerek!
Először is szeretném elmondani, hogy ez a tananyag sorozat egyszerűen fantasztikus. Annyira könnyed és lényegre törő és sokat mondó.
Másodszor eddig a pontig (Függvények, szövegfájlok, többdimenziós listák) nagyon jól haladtam tanulásban és megértésben is. Aztán itt jött a probléma, ebben a tömben lévő három anyag kicsit kifogott velem. Értem a lényegét mind a három anyagnak, de nem olyan magabiztosan. Nem értem az egészet, és ez most nagyon zavar. Annyira, hogy most nem tudom a hogyan továbbot. Ezért szeretném kérni a tanácsodat.
Mit tegyek most? Mit csináljak, hogy megértsem ennek a három leckének minden részletét?
Addig nem szeretnék továbbhaladni, mert ezek fontos részek.
Kérlek adj tanácsot.
Köszönöm szépen előre is.
Üdvözlettel: Ádám
KedvelésKedvelés
Szia Ádám!
Ha túl vagy az összes feladaton is, akkor szerintem két utad van:
Vagy tegyél fel konkrét kérdést, és akkor megpróbálok segíteni,
vagy megnézed a következő leckéket, és ha addigra sem érted, akkor visszatérsz ide.
KedvelésKedvelés
Köszönöm szépen a válaszodat. Lesz több kérdésem is, viszont először beírnám az saját megoldásomat az utolsó feladatról. Ezt azért teszem, mert szerintem nem a legjobb. Működik egyébként, csak az a megérzésem, hogy lehetne sokkal egyszerűbben.
F0029g: Hány gólt rúgtak az egyes posztokon lévő játékosok átlagosan?
def atlag_golok_csatar():
golok = 0
poszt = 0
for elem in lista:
if elem[1] == ‘csatar’:
golok += int(elem[3])
poszt += 1
atlag_gol = golok / poszt
return atlag_gol
def atlag_golok_kozeppalyas():
golok = 0
poszt = 0
for elem in lista:
if elem[1] == ‘kozeppalyas’:
golok += int(elem[3])
poszt += 1
atlag_gol = golok / poszt
return atlag_gol
def atlag_golok_hatved():
golok = 0
poszt = 0
for elem in lista:
if elem[1] == ‘hatved’:
golok += int(elem[3])
poszt += 1
atlag_gol = golok / poszt
return atlag_gol
listak = []
forrasfajl = open(‘Feladat005.txt’, ‘r’)
for sor in forrasfajl:
listak.append(sor.strip().split())
forrasfajl.close()
print(‘A csatárok átlag gólszáma: ‘, atlag_golok_csatar(), ‘\n’
‘A középpályások átlag gólszáma: ‘, atlag_golok_kozeppalyas(), ‘\n’
‘A hátvédek átlag gólszáma: ‘, atlag_golok_hatved(), ‘\n’)
KedvelésKedvelés
A frappánsság titka az lesz, hogy olyan függvényt írsz, aminek a paramétere a poszt:)
Frappánsítsd tovább a megoldást, ha odajutsz: ne definiáld a posztok nevű listát, hanem rakd össze a bemeneti fájlban előforduló posztokból. Kérdezz bátran, ahogy odajutok, válaszolok:)
def mennyitrúgtak(szerep):
#a paraméter neve szándékosan nem poszt, bár az is lehetne
#akkor ez egy másik poszt nevű változó volna, nem ugyanaz, mint a lenti
ennyit = 0
for focista in focisták:
if focista[1] == szerep:
ennyit += int(focista[-1])
return ennyit
focisták = []
forrásfájl = open(‘bemenet.txt’)
for sor in forrásfájl:
focisták.append(sor.strip().split())
forrásfájl.close()
posztok = [‘hatved’, ‘csatar’, ‘kozeppalyas’]
for poszt in posztok:
print(poszt, ‘: ‘, mennyitrúgtak(poszt), sep=”)
KedvelésKedvelés
F0029d: Valahogy máshogy jár az agyam… Végülis működik:)
focistak = []
golok = []
forrásfájl = open(‘foci.txt’)
for sor in forrásfájl:
focistak.append(sor.strip().split()[0])
golok.append(int(sor.strip().split()[3]))
forrásfájl.close()
keresett = min(golok)
print(keresett, ‘a legkevesebb gól, ‘, end = ”)
print(focistak[golok.index(keresett)], ‘az elkövető.’)
KedvelésKedvelés
Teljesen rendben van, ha az ilyen elemi feladatoknál szétszeded az adatokat – később meg, ha nagyobb táblákkal dolgozol, akkor úgyis egyben fogod őket tartani, vagy pedig objektumokat készítünk majd belőlük, hiszen van, ahol az lesz a célravezető.:)
KedvelésKedvelés
Hasonló kérdésem van – azt hiszem – mint az előttem hozzászólónak. Az nem gond, ha szétszedem az adatokat, vagyis csináltam egy újabb listát a b és a c feladatban a csapatrészeknek és abban count tagfüggvénnyel számoltam:
def csapatreszek(ketdlista, poszt):
csapatresz_lista =[]
for sorlista in ketdlista:
csapatresz_lista.append(sorlista[1])
return csapatresz_lista.count(poszt)
KedvelésKedvelés
Jelen szintünkön nem gond, egyáltalán. Gond olyankor lesz majd, ha nagyon sok adattal dolgozol, hiszen most van egy plusz adatmásolós műveleted, ami végső soron idő és memória.
KedvelésKedvelés
Kedves Raerek és evezős társaim!
Megpróbáltam magából a fájlból meghatározni a posztokat is.
Működik, de lehetne-e egyszerűsíteni? Nem éreztem most fontosnak függvényt készíteni.
https://trinket.io/python/7134a7f3cd
KedvelésKedvelés
Jól csináltál mindent:
önállóan fedezi fel a posztokat
megtart minden információt, hátha később mást kell számolni belőle
Azt lehetne még csinálni, hogy amikor felfedez egy új posztot, akkor végigrohan a fájl maradék részén, mert ugye aleddig tutira nem volt olyan poszt, elég, ha a hátralévőt nézi végig. Kérdés, hogy ez a bonyolítás nem teszi-e túlzottan átláthatatlanná a programot. Biztos megvan az a mennyiségű és jellegű adat, ahol már megéri így csinálni, itt szerintem a te megoldásod a jó.
Akkor lehetne egyszerűsíteni, ha beledrótoznád a programba a lehetséges posztokat.
KedvelésKedvelik 1 személy
F0029b-hez egy rövidebb megoldást hasznaltam:
forras = open(‘/tmp/szoveg.txt’,’r’)
sorok_szama = 0
for sor in forras:
if sor.strip().split()[1] == ‘csatar’:
sorok_szama += 1
print(sorok_szama)
forras.close()
KedvelésKedvelés
A 0029d-t, igaz nem függvénnyel (hisz az eredeti feladatban nem szerepelt ez a kitétel), de szerintem egyszerűbben oldottam meg. A fájl megnyitás/lezárás így ok ugye (azaz, hogy mindkétszer nyitom/zárom)?:
forras = open(‘/tmp/szoveg.txt’,’r’)
legkevesebb_gol = 50
for sor in forras:
gol = sor.strip().split()[3]
if int(gol) < int(legkevesebb_gol):
legkevesebb_gol = gol
forras.close()
forras = open('/tmp/szoveg.txt','r')
for sor in forras:
rekord = sor.strip().split()
if rekord[3] == legkevesebb_gol:
print(rekord[0],rekord[1])
forras.close()
KedvelésKedvelés
Oké, ahogy nyitsz-zársz, de nem volna szükséges. Más kérdés, hogy itt nem foglalkoztunk azzal, hogy miként mész vissza a fájl elejére, erre a forras.seek(0) a jó, emlékeim szerint.
Ha ez a fájl viszonylag nagy, akkor lényegesen gyorsabb lehet egyszer beolvasni a memóriába (már ha nem akkor a fájl, hogy nem fér el odabenn), és abban kolbászolni kétszer.
Más: ez az int fölösleges, int(legkevesebb_gol)
de csak akkor, ha legkevesebb_gol = int(gol)-lal teszed el. Így megint csökken a műveletigény:)
KedvelésKedvelés
Ha a F0029f-et nem listával oldom meg (csak egy ciklus van benne), az is jó ?
forras = open(‘/tmp/szoveg.txt’,’r’)
golok = 0
jatekos = 0
for sor in forras:
golok += int(sor.strip().split()[3])
jatekos += 1
forras.close()
print(jatekos,’jatekos osszesen’,golok,’golt rugott. Az atlag:’,golok/jatekos,’gol’)
KedvelésKedvelés
Jó bizony:) Én ugye azért listával csináltam, mert úgy voltam vele, hogy az előző feladatok okán amúgy is van listám már.
KedvelésKedvelés
Én többnyire teljesen új python fájt írok mindig, hogy gyakoroljak.. 😉
KedvelésKedvelés
Szia!
Tudnál kicsit segíteni? Egy érettségis feladatsorban elakadtam.Nem tudom, hogy a 7-es feladattól, hogy kellene, és én szerdán írok infóból. (nem emelten)
Click to access k_infoism_17okt_fl.pdf
az egyszamjaték.
eddig így oldottam meg:
naplo = []
forrasfajl = open(‘egyszamjatek.txt’)
for sor in forrasfajl:
sor = sor.strip().split()
f1 = int(sor[0])
f2 = int(sor[1])
f3 = int(sor[2])
f4 = int(sor[3])
f5 = int(sor[4])
f6 = int(sor[5])
f7 = int(sor[6])
f8 = int(sor[7])
f9 = int(sor[8])
f10 = int(sor[9])
nev = sor[10]
naplo.append([f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, nev])
szamok =[]
print(‘3. feladat: Játékosok száma:’,len(naplo))
for elem in naplo:
nevek = elem[-1]
fordulok = elem[:-1]
szamok.append(fordulok)
print(‘4. feladat: Fordulók száma: ‘, len(fordulok))
for elem in naplo:
if elem[0] == 1:
print(‘5. feladat: Az első fordulóban volt egyes tipp!’)
break
else:
print(‘5. feladat: Az első forduloban nem volt egyes tipp!’)
legnagyobb = max(szamok)
print(‘6. feladat: A legnagyobb tipp a fordulók sorám: ‘, max(legnagyobb))
fordulo_szam = input(‘Kérem a forduló sorszámát [1−10]: ‘)
remélem nem túl rossz 🙂
KedvelésKedvelés
Egyáltalán nem:)
Itt a megoldás, friss, ropogós. Nem néztem át, úgyhogy, ha kölcsönvehetem a szavaidat, “remélem, nem túl rossz:)”: https://pastebin.com/tnHFw7BM
KedvelésKedvelés
Nagyon szépen köszönöm. Kicsit komolyabb az enyémnél. Van még mit tanulnom 😀
KedvelésKedvelés
Szia!
Az utolsó feladatot “frappánsan” szerettem volna megoldani, de mint az alábbiakban láthatod nem igazán sikerült. Esetleg rá tudnál világítani, hogy miképp oldjam meg ezzel a módszerrel? Vagy lehetetlen? A válaszodat előre is köszönöm!
#29g
feladat = {}
for sor in játékosok:
feladat[sor[1]] = feladat.get(int(sor[3]), 0) + (int(sor[3])
print(feladat)
//A végeredmény:
{‘hatved’: 2, ‘csatar’: 4, ‘kozeppalyas’: 3}
KedvelésKedvelés
Először is: nagy örömömre szolgált látni, hogy ezzel a módszerrel próbálkozol. Így hajnalban két bajt látok: a) ez összeg lesz és nem átlag b)a get-nél ugye kulcsot akarod megadni, ami sor[1].
Itt a működő verzió (persze ez is még összeget számol):
játékosok = open(‘fájl.txt’)
feladat = {}
for sor in játékosok:
sor = sor.strip().split()
print(sor)
feladat[sor[1]] = feladat.get(sor[1], 0) + (int(sor[3]))
print(feladat)
Két megjegyzés még:
1) Már érdemes beolvasáskor int()-ni amit kell
2) Most ebből átlag akkor lesz, ha megszámolod még egyszer, hogy melyi poszt hányszor van. Az vagy még egy szótár, vagy olyan szótárat hanszálsz eleve, ahol minden értrék is egy lista, vagy szótár.
KedvelésKedvelés
Köszönöm! Sikerült 😀
(Még egy szótárral csináltam)
feladat1 = {}
feladat2 = {}
for sor in játékosok:
feladat1[sor[1]] = feladat1.get(sor[1], 0) + int(sor[3])
feladat2[sor[1]] = feladat2.get(sor[1], 0) + 1
for k, v in feladat1.items():
for key, value in feladat2.items():
if key == k:
print(key, “: “, round(int(v) / int(value), 1))
Legközelebb pedig előbb gondolkodok a typeokról 🙂
KedvelésKedvelés
Szia Ráérek és lelkes sorstársaim!
Kérlek ráérek segíts nekem mert nagyon nehezen veszem fel a ritmust a függvény készítéssel és a f0029d feladat 1 függvénnyel iródótt meg és az lenne a kérdésem, ha nem jó akkor miért nem jó?
Kérlek kötekedj!! és ird le nyugodtan nyersen tömören a véleményed ,ha esetleg van fölös néhány perced.
Előre is köszönöm és nem tudom elégszer megköszönni az oldalad nagyszerűségét tanár úr!
def legkevesebb_gól(lista):
gólók = []
for i in range(len(lista)):
gólók.append(int(lista[i][3]))
if gólók[i] == min(gólók):
print(‘A legkevesebb gólt : ‘,lista[i][0],’ rúgta! Póziciója : ‘,lista[i][1],sep=”)
return gólók
focisták = []
forrásfájl = open(‘bemenet.txt’)
for sor in forrásfájl:
focisták.append(sor.strip().split())
forrásfájl.close()
legkevesebb_gól(focisták)
KedvelésKedvelés
Halihó!
Ha jól sikerült a behúzásokat helyreállítanom, akkor két nyűg van vele, kezdem a picivel, hátha a végére el is felejtődik:) A függvény alapvetően nem beszélget, nem ír eredményt, hanem visszaadja azt a hívónak, és majd az kiírja, amit kell. Ez most így eljárás, nem függvény, ebből a szempontból (lásd: https://pythonidomar.wordpress.com/2016/12/06/erre-megvannak-az-embereim/). Bár adsz vissza értéket, azt nem használod fel.
A nagyobbik, amitől kifejezetten hibás lesz a megoldás, az az, hogy a legkisebb gólt csak az eddigiekhez képest veszed észre. (Ezt értsd meg, addig ne menj tovább.)
Teszteld le úgy a programodat, hogy folyamatosan csökkenő gólokat adsz meg mindenkinek: mindenkit meg
fog találni, mert az eddigiek közül az övé a legkisebb.
Ezért dolgozunk két lépésben: először megkeressük a legkevesebb gólt az egész mezőnyben, és aztán megnézzük, hogy kinek van annyi.
KedvelésKedvelik 1 személy
Nagyon szépen köszönöm ezt a gyors választ!
Valóban ha csökkenő sor rendbe állítom be a gólókat nem úgy működik mint amit elképzeltem.
Háát nagy fejtörés volt még ígyis meg érteni ,hogy miért viselkedik így programom de ,hogy rá mutattál
vissza nézegettem a videokat ééésss BINGO 😀
Nagy dilemmám volt a visszatérési érték kiválasztásával ,hogy milesz a visszatérési értéke a függvényemnek ??? ,de most már azt is értem az lesz maga az eredménye és azzal robogok búzgón vissza!
Köszönöm szépen még 1x rengeteget segitettél!!
KedvelésKedvelés
Szia!
F0029c-nél mennyire elfogadható ez a megoldás?:
forras = open(“file123.txt”)
def szamolo(poszt):
szam = 0
for sor in forras:
sima = sor.split()
if poszt in sima:
szam = szam + 1
print(“A csapatban”, szam, poszt, “van.”)
Szép napot!
KedvelésKedvelés
Ez suliban még alighanem ötös, szóval jó vagy, de fejlesztői szemmel hadd említsek meg két bajt:
az egyik egy nem figyelés, nem teljesítetted a feladatkiírást (márpedig a programozó specifikáció után dolgozik, ha minden jól megy): “A függvény két paramétere a 2D lista, illetve a megszámolandó játékosok posztja.” Ezzel a a baj, hogy ha a kollégád írja azt a programrészt, ami a függvényedet használja, akkor nem fog menni a programotok. De ezt még ráérsz megtanulni:)
A másik hiba sem túl komoly, de azért elmondom, hogy tanuld a gondolkodásmódot. Mondjuk, hogy valakinek nem a keresztneve, hanem a vezetékneve szerepel, és épp Csatár Béla a neve, de közben meg hátvéd. A programod még mindig nem találja meg, mert a csatár nem Csatár, de ha ehhez veszünk egy edzőt, aki a posztot nagybetűvel kezdi, akkor kész a baj. Az igazi programok nagyon nagy része azzal van elfoglalva, hogy hülyeálló legyen, érdemes mindenre számítanod, pl. ilyesmire is.
KedvelésKedvelik 1 személy
Végre sikerült az F0029g, és talán végre a függvényeket is értem: https://pastebin.com/qrw9nMY0
Viszont a végén azzal a sok printtel nem vagyok kibékülve, hogy lehetne ezt egyszerűbben? 😀
KedvelésKedvelés
Írhatsz ilyet:
print(‘Csatárok: ‘, gólszámláló(lista,’csatar’), ‘db gól’)
KedvelésKedvelés
Ah köszi, amikor így próbáltam, kaptam egy TypeError: gólszámláló() takes 2 positional arguments but 3 were given-t, és azt hittem így nem lehet, de akkor valószínű csak a zárójel rossz oldalára írtam a ‘db gól’-t 😀
KedvelésKedvelés
tgen:) ez kb ennyi:) mármint: 3 dolog volt a zárójelben, de csak kettőt várt a függvényed, és összecsinálta magát tanácstalanságában:)
KedvelésKedvelés
Szia Ráérek
Az alábbi problémákba ütköztem a g feladatnál a függvényemmel:
-ha beírom a printbe a posztot akkor működik de kiír egy ‘None’-t is a végén.
-próbáltam cifrázni és egy inputot beilleszteni a függvény bemeneti értékéhez, de nem sikerült életre kelteni, zerodivision hibát ír, tehát a függvényben levő játékos változót valamiért nullán hagyja de nem értem hogy miért. Az input kéri az adatot, de az valamiért nem jó a függvénynek, hiába írom be úgy mint ahogy a fájlban van.
https://pastebin.com/95sgCGpU
KedvelésKedvelés
Az a nyűg, hogy te a függvényed utolsó előtti sorában nem kiszámolod, hanem kiírod az adatot. A kiírást függvényben lévő print a print végzi, és az a None a print visszatérési értéke ()ugye a print maga is egy beépített függvény). Ez kerül bele az eredmény nevű változódba, és ezt adja vissza a return. És így ezt írja ki a másik, a főprogramban lévő print.
A megoldás lehet, hogy
vagy a függvény kiírja az eredményt, és akkor nem kell betöltened az eredmény nevű változóba, illetve nem is adsz vissza semmit (nincs return a függvényben, ilyenkor ugye nem is függvény, hanem eljárás a neve, csak ezt a kettőt a python nem különbözteti meg
vagy nincs print a függvényben, csak kiszámolod és visszaadod az eredmény értékét, és majd a főprogram írja ki.
Ha nem vili, akkor írd meg ezt a programot:
def függvény()
eredmény = print(‘bármi’) #ez kiírja, hogy bármi
return eredmény
print(függvény) #ez meg azt, hogy None, ami a másik print visszatérési értéke
KedvelésKedvelés
Szia ráérek!
A F0029a feladatnál, a két megoldást egymás után szeretném kiírni, de sajnos egybe nem megy, de külön pedig igen. Mi ennek az oka? Ezekszerint nem tudom kétszer úgy végigmenni a forrásfájlban, hogy csak egyszer nyissam meg a txt?
lista=[]
forrásfájl=open(‘bemenet2.txt’)
for sor in forrásfájl:
lista.append(sor.strip().split()[0])
print(‘, ‘.join(lista))
for sor in forrásfájl:
print(sor.strip().split()[0],’, ‘,sep=”,end=”)
print()
forrásfájl.close()
KedvelésKedvelés
Alapból azért nem, mert hol mondod meg a programnak, hogy kezdje elölről a fájlt? Természetesen vannak olyan módszerek, amelyben lehet egy fájlon belül mozogni, pl: https://stackoverflow.com/questions/11696472/seek-function .
KedvelésKedvelés
Szia raerek!
Már régóta nézem a videóidat, de úgy tűnik csak most jött el az idő, hogy hozzászóljak valamelyikhez.
Idén szeretnék érettségizni infóból, a programozási részét a te videóidból próbálom megtanulni. Őszintén, én már leérettségiztem, de szeretnék infóból is egy emelt szintűt. Infó faktra jártam, de viszont valamiért nem jött be a programozás, így leadtam. Most egy évvel később megint belepróbáltam és valamiért megváltozott az álláspontom, megkedveltem a programozást. Ha jól emlékszem vagy videódban vagy a weboldalon mondtad/írtad, hogyha valamelyik iskolában a te videóidat is felhasználják, oktatásként akkor írjuk le, a tanár a te weboldaladat ajánlotta gyakorlásként(és szerintem ő is innen merítette az órák anyagait), így találtam rád én is(suli alatt is néztelek csak nem foglalkoztam a programozással annyit). Mint ezt már sokan megtették, én is szeretném megköszönni a munkádat, rettentően jól magyarázod el a dolgokat. Azért, hogy ne csak rizsa legyen jöttem egy problémával:
def tenmatch(lista):
mennyi = str(10)
ki = []
for elem in lista:
if elem[2] >= mennyi:
ki.append(elem[0])
return ki
lista = []
forrásfájl = open(“foci.txt”)
for sor in forrásfájl:
lista.append(sor.strip().split())
print(tenmatch(lista))
Itt az lenne a problémám, hogyha a mennyi = 10 akkor mindenkit belevesz a listába, ellenkező esetben mindenkit jól leír, pl 9-nél a 9 meccseseket beleveszi a listába kivéve szegény Bélát nem.
Remélem ennyi sok idő után is itt vagy az oldalon.
Még egyszer köszönöm a munkádat, várom a válaszodat, szia!
KedvelésKedvelés
Köszönöm a méltatást, és hoooógyne lennék:)
Szóval a programodban a mennyit stringként hasonlítod össze, és ez okozza a problémát (már ha jól értem a problémafelvetésedet).
str(10) és str(9) közül a 9 a nagyobb, mert 9>1, a stringek összehasonlításakor ugyanis csak az első karaktert veszi figyelembe, ha az egyezik, akkor a másodikat és így tovább. Mint a hogy te is ABC-be rendezel.
A kevésbé jó megoldás az, ha nem a mennyit alakítod stringgé, hanem az elem[2]-t számmá, és úgy hasonlítod össze őket.
Az igazi jó megoldás meg az, ha a számokat már a fájl beolvasás a során számmá alakítod.
KedvelésKedvelés
Ohh, megvan igen, jól értetted a problémafelvetésem.
Köszönöm a válaszodat!
KedvelésKedvelés