<jupyter_start><jupyter_text>Najboljše videoigre vseh časov **Projektna naloga pri predmetu Programiranje 1**  0. Priprava podatkov Preden sploh lahko začnemo z analizo podatkov, moramo seveda pripraviti vse potrebno. V ta namen uvozimo knjižnico pandas in vnesemo naše tabele.<jupyter_code>import pandas as pd

pd.options.display.max_rows = 30

%matplotlib inline

igre = pd.read_csv("igre.csv")
zanri = pd.read_csv("zanri.csv")
igre
zanri<jupyter_output><empty_output><jupyter_text>1. Kaj pomeni "najboljša videoigra"? Da bo naslov te projektne naloge upravičen, bi se spodobilo, da najprej dorečemo, kaj sploh pomeni, da je igra "najboljša". Igre so na spletni strani Metacritic, s katere sem prenesel podatke, razvrščene po oceni **metascore**. Tu jih bomo ocenjevali malo drugače.Konstruirali bomo lastno metriko za rangiranje. Bralec se morda sprašujemo zakaj je to potrebno. Razlogov je več:* Neobelani podatki so razvrščeni po **metascore**, torej ocenah strokovnjakov. Ne upoštevamo mnenja običajnega igralca.* Nikjer ne upoštevamo števila ocen, kar lahko pripelje do patoloških primerov. Igra, ki ima 5 glasov in oceno 9.0, intuitivno seveda ni enako dobra kot igra, ki ima 5000 glasov in oceno 8.5.* Do neke mere bi radi upoštevali, da je igra z malo glasovi in dobro oceno boljša od igre z veliko glasovi, ki pravijo, da je slaba. Najprej malo preletimo podatke, da vidimo, s čim sploh imamo opravka.   Userscore **Userscore** je ocena, ki jo dajo običajni uporabniki spletne strani. Poglejmo, kaj nam lahko pove.<jupyter_code>igre.plot.scatter(x="glasovi userscore", y="userscore")
igre[igre["glasovi userscore"] > 10 ** 5]<jupyter_output><empty_output><jupyter_text>V redu, zanimiv začetek ...Za bralca, ki ni na tekočem s svetom videoiger, *The Last of Us* je bila ena najbolj uspešnih videoiger za *PlayStation 3* ter *PlayStation 4* in ena najbolj uspešnih videoiger nasploh. Je kanoničen primer, ko zagovarjaš, da igre niso samo streljačine, ampak celoten medij, ki se lahko ob rob postavi knjigi in filmu. Ko bomo iskali najboljše igre na teh platformah, bomo to gotovo našli med njimi.Skratka, igra je izšla 2013 in oboževalci so čakali 7 let na njeno nadaljevanje, *The Last of Us Part II*, ki pa je bila dokaj kontroverzna. Oddaljila se je od sporočila prve igre in se usmerila v LGBT vsebine. To je skupaj z napihnjenimi pričakovanji občinstva pomenilo, da je veliko ljudi želelo izraziti svoje mnenje o igri. Ravno to lahko opazimo v zgornjem grafu. Morda se sedaj osredotočimo na območje, kjer je glavnina podatkov.<jupyter_code>igre[igre["glasovi userscore"] < 1000].plot.scatter(x="glasovi userscore", y="userscore")<jupyter_output><empty_output><jupyter_text>Vidimo, da več kot je glasov, boljše so igre. Torej je smiselno število glasov upoštevati pri naši oceni. Naredimo sledeče:**Prilagojen userscore** izračunamo po naslednji formuli: `Up = U * (Gu / (Gu + GuAv))`,  kjer je `U` prvotna ocena, `Gu` število glasov in `GuAv` povprečno število glasov.S tem smo dosegli sledeče:* Igre z visoko oceno in velikim številom glasov bodo obdržale prestižno oceno.* Igre z nizko oceno in velikim številom glasov bodo ostale slabo ocenjene.* Igre s sicer malo glasovi, ampak z res dobro oceno bodo povprečno ali celo nadpovprečno ocenjene.* Za igre z nizko oceno in malo glasovi smatramo, da niso dovolj popularne, zato se njihova ocena zmanjša.Če je glasov veliko, ocena ostane skoraj enaka. Če pa je glasov malo, se ocena temu primerno prilagodi, pri čimer pa lahko res dobra igra vseeno izstopa.Tako smo graf ocene v odvisnosti od glasov nekoliko linealizirali.<jupyter_code>def prilagodi_glasove_userscore(tabela_iger):
    def prilagodi(ocena, st_glasov, medijana_glasov):
        return round(((st_glasov) / (st_glasov + medijana_glasov)) * ocena, 2) 
    tabela_iger["prilagojen userscore"] = prilagodi(
        tabela_iger["userscore"], tabela_iger["glasovi userscore"], (tabela_iger["glasovi userscore"]).mean()
        )

prilagodi_glasove_userscore(igre)
igre[igre["glasovi userscore"] < 1000].plot.scatter(x="glasovi userscore", y="prilagojen userscore")<jupyter_output><empty_output><jupyter_text>Metascore<jupyter_code>igre.plot.scatter(x="glasovi metascore", y="metascore")<jupyter_output><empty_output><jupyter_text>Tu opazimo, da kvaliteta iger s številom glasov ne narašča. To je po pričakovanjih, saj proizvajalci pogosto podarijo igro ocenjevalcem, da jo ti ocenijo in s tem naredijo reklamo. Število glasov je torej v veliki meri odvisno od proizvajalca in ga zato tu ne bomo upoštevali. Poleg tega so števila glasov stokovnjakov veliko nižja v primerjavi s števili glasov uporabnikov, zato izračun po zgornji enačbi v tem primeru ne bi bil realen.Oceno strokovnjakov bomo le delili z 10, da bosta userscore in metascore števili istega reda velikosti.  Torej **prilagojen metascore** dobimo po formuli: `Mp = M / 10`, kjer je `M` metascore.<jupyter_code>def prilagodi_glasove_metascore(tabela_iger):
    tabela_iger["prilagojen metascore"] = tabela_iger["metascore"] / 10

prilagodi_glasove_metascore(igre)<jupyter_output><empty_output><jupyter_text>Prilagojena ocena Naša **prilagojena ocena** bo vsota prilagojenega metascora in prilagojenega userscora. In ko smo ravno pri tem, bomo še odstranili igre, ki niso ocenjene.<jupyter_code>def prilagojena_ocena(tabela_iger):
    tabela_iger["prilagojena ocena"] = tabela_iger["prilagojen userscore"] + tabela_iger["prilagojen metascore"]
    tabela_iger.dropna(subset=["prilagojena ocena"], inplace=True)

prilagojena_ocena(igre)
igre<jupyter_output><empty_output><jupyter_text>Sedaj imamo našo metriko za ocenjevanje iger in prava analiza podatkov se lahko prične. Poglejmo, katere videoigre so najboljše.<jupyter_code>igre.sort_values("prilagojena ocena", ascending=False).head(15)<jupyter_output><empty_output><jupyter_text>Sedaj pa uredimo igre po prilagojeni oceni in jih preindeksiramo. Tako bomo lahko hitro videli, na katerem mestu seznama je določena igra.<jupyter_code>igre = igre.sort_values("prilagojena ocena", ascending=False)
igre.reset_index(drop=True, inplace=True)

igre<jupyter_output><empty_output><jupyter_text>2. Kaj nam povedo podatki?  Userscore in metascore Razliko med oceno *userscore* in *metascore* smo že omenili. Raziščimo to bolj podrobno.Metascore je ocena "strokovnjakov" na področju videoiger. Ti preigrajo igro ob izidu in so vir prvih informacij o kvaliteti. Iz istega razloga podjetja skušajo dobiti dobre ocene na račun daril in drugih bonitet.Userscore je ocena običajnih igralcev in uporabnikov. Ti preživijo več časa z igro in zato nudijo bolj dologoročno mnenje.Poglejmo, kakšne razlike lahko opazimo.<jupyter_code>igre.plot.scatter(x="metascore", y="userscore")
igre.plot.scatter(x="prilagojen metascore", y="prilagojen userscore")<jupyter_output><empty_output><jupyter_text>Nič presenetljivega ne opazimo, točke so precej enakomerno porazdeljene. Morda res vidimo, da se oba tabora strinjata pri kvaliteti najboljših iger. Toda lahko izluščimo nekaj zelo zanimivega.Ne smemo pozabiti, da so surovi podatki 10000 iger z najboljšim metascorom. Vendar pa pri userscoru vidimo precejšnjo varianco. Torej so igre, ki jih strokovnjaki ocenjujejo nadpovprečno, vseeno zelo mešane kvalitete. Prvi graf na to namiguje, drugi pa to potrdi. Sklepamo lahko, da se mnenja strokovnjakov in uporabnikov ne ujemajo nujno.  Katere igre so najboljše? Preden odgovorimo na to vprašanje, bomo ločili igre glede na platformo. Različna strojna oprema in različna implementacija pomenita, da se lahko kvaliteta od platforme do platforme precej razlikuje. Zato bomo v določenih pogledih obravnavali najboljše igre na vsaki platformi posebej.<jupyter_code>igre.platforma.unique()<jupyter_output><empty_output><jupyter_text>Na tem mestu bomo iz nadaljne analize izvzeli igre, ki so na platformi *Stadia*. No, pravzaprav dve igri:<jupyter_code>igre[igre["platforma"] == "Stadia"]<jupyter_output><empty_output><jupyter_text>*Stadia* je *cloud gaming service*, ki ga je razvil *Google*. Ideja je preprosta. Z mesečno naročnino imaš dostop do računalniške strojne opreme, ki jo nudi *Google*, tako da doma ne potrebuješ najzmogljivejših konzol. Potrebuješ samo zaslon, tipkovnico ali kontroler in dovolj dobro internetno povezavo. Ideja je v teoriji sicer dobra, vendar se v praksi še ni tako zelo prijela. Dejstvo, da sta med 10.000 najboljšimi igrami le dve s te platforme, je dokaz tega, in bomo zato brez slabe vesti *Stadio* izvzeli iz nadaljnje analize.<jupyter_code>seznam_platform = igre[igre["platforma"] != "Stadia"]["platforma"].unique()
seznam_platform 
igre_po_platformi = {}
for platforma in seznam_platform:
    igre_po_platformi[platforma] = igre[igre.platforma == platforma]

igre_po_platformi["PC"]<jupyter_output><empty_output><jupyter_text>Sedaj lahko končno odgovorimo na glavno vprašanje te projektne naloge. Katere so najboljše videoigre?<jupyter_code>igre[["naslov", "platforma", "prilagojena ocena"]].head(20)<jupyter_output><empty_output><jupyter_text>Poglejmo še, katere so najbolj priljubljene igre na posamezni platformi:<jupyter_code>for platforma in igre_po_platformi:
    display(platforma)
    display(igre_po_platformi[platforma][["naslov", "prilagojena ocena"]].sort_values(
        "prilagojena ocena", ascending=False).head(5))<jupyter_output><empty_output><jupyter_text>V nadaljnji analizi bomo ponekod pogledali le podatke **dobrih iger**, torej tiste, ki so v prvi polovici, in **najboljše igre**, ki so v prvih 5 %. Zato nam bo prišlo prav, če na tem mestu uvedemo ti dve skupini iger:<jupyter_code>dobre_igre = igre.head(5000)
najboljse_igre = igre.head(500)<jupyter_output><empty_output><jupyter_text>Katera platforma je nabolj uspešna? Zanima nas, katera **platforma** je bila najbolj uspešna. Enostavno preštejmo, koliko iger se je pojavilo v naših podatkih:<jupyter_code>st_iger_na_platformo = igre.groupby("platforma").size().sort_values()
st_iger_na_platformo.plot.bar()<jupyter_output><empty_output><jupyter_text>Da je računalnik najbolj priljubljena platforma, nas ne preseneča. Nekoliko nepošteno je primerjati konzole z račualnikom, saj se računalniki sčasoma spreminjajo, si izboljšujejo strojno opremo, pa vendar ostajajo pod istim imenom. Konzole pa izidejo z neko strojno opremo in ko je ta zastarela, izide naslednja generacija konzol. Tako imamo sosledja *PlayStation 2*, *PlayStation 3*, *PlayStation 4* in *Xbox*, *Xbox 360*, *Xbox One*.Med konzolami so torej najboljše *PlayStation 4*, *Xbox 360*, *PlayStation 3*. Če smo se že tako trudili, da smo naredili lastno metriko, poglejmo, na katerih konzolah se pojavijo najboljše igre.<jupyter_code>st_iger_na_platformo_najboljse = najboljse_igre.groupby("platforma").size().sort_values()
st_iger_na_platformo_najboljse.plot.bar()<jupyter_output><empty_output><jupyter_text>Opazimo zelo podobne rezultate. Med konzolami še vedno prevladuje *PlayStation 4*, tik za petami pa sta mu tokrat ročna konzola *Switch* in nato *PlayStation 2*. Pozoren bralec bo opazil, da se igre z istim imenom pojavijo večkrat na različnih platformah. Kot rečeno, se lahko izkušnja od platforme do platforme precej razlikuje. *PlayStation 4* ima na primer kontroler, ki se trese, medtem ko igraš, *Switch* ti nudi igranje na poti, *PC* pa seveda najboljše grafične zmogljivosti.To, da pa igre nastopajo na različnih platformah, nam da izvrstno priložnost, da jih med sabo primerjamo. Izkušnja ne bo odvisna od vsebine igre, temveč samo od zmožnosti platforme.<jupyter_code>naslovi = igre.naslov.unique()
veckratni = []
for naslov in naslovi:
    if igre.groupby("naslov").size()[naslov] > 1:
        veckratni.append(naslov)
        
score = {}
for naslov in veckratni:
    top_platforma = igre[igre.naslov == naslov].sort_values("prilagojena ocena").iloc[0]["platforma"]
    if top_platforma in score.keys():
        score[top_platforma] += 1
    else:
        score[top_platforma] = 1
konzole = pd.DataFrame(list(score.items()), columns = ['platforme','točke']).sort_values("točke")
konzole.plot.bar(x="platforme", y="točke")<jupyter_output><empty_output><jupyter_text>Rezultati presenetljivo prikazujejo, da je najbolje igrati na *Xbox One*. Eno izmed vprašanj, na katero sem želel odgovoriti, je stalnica v svetu videoiger že od leta 2013. Katera konzola je boljša, *PlayStation 4* ali *Xbox One*? Na to vprašanje tudi sedaj ne bom odgovoril, saj ne vem, kakšnega prepričanja je ocenjevalec moje projektne naloge. Na podlagi podatkov pa lahko naredimo naslednje sklepe.S stališča zmogljivosti je *Xbox One* boljša, saj so igre na njej najbolje ocenjene. Kljub temu pa je, kot pikazujeta prejšnja grafa, večji del najboljših iger na *PlayStation 4*. Razlog je v tem, da *Sony*, podjetje, ki je lastnik konzol *PlayStation*, razvija ekskluzivne igre, ki jih lahko igraš samo na njihovih platformah. Ker morajo te igre prepričati ljudi, da zanje kupijo konzolo, so pogosto boljše. *Microsoft*, lastnik *Xbox* konzol, je dolgo poskušal najti svoje ekskluzivne igre, a se preprosto ne morejo kosati z naslovi, kot so *The Last of Us*, *God of War* ali *Spider Man*. Nasploh ima *Microsoft* drugačno mentaliteto, kar se tega tiče. Kvečjemu poskrbijo, da igre ne izidejo na *PlayStation* konzolah, vseeno pa izidejo na računalnikih. Debata ostaja odprta.Ob času pisanja pa smo ravno v napetem obdobju, ko izhaja nova generacija igralnih konzol; *PlayStation 5* in *Xbox Series X*.Trenutno kaže, da v bitki vodi *PlayStation 5*.  Kateri studio je najbolj uspešen? Sedaj poglejmo, kateri **studio** se lahko pohvali z najboljšimi igrami.<jupyter_code>st_iger_na_studio_najboljse = najboljse_igre.groupby("studio").size().sort_values(ascending=False).head(20)
st_iger_na_studio_najboljse.plot.bar()<jupyter_output><empty_output><jupyter_text>*Ninetendo*. Ta rezultat gotovo nikogar ne preseneča. *Mario*, *Legend of Zelda*, *Pokemon*, *Metroid*, *Animal Crossing*, *Smash Bros*. Te naslove gotovo vsi poznamo. Pisalo se je 1985, ko je *Nintendo* na Japonskem izdal *Super Mario Bros.* in leto pozneje je ta uspešnica skupaj z *Metroid* in *Legend of Zelda* zavzela ZDA.Začelo se je obdobje videoiger, kot jih poznamo danes. Torej ne na arkadah, ampak doma. *Nintendo entertainment sistem* ali *NES* je bila ena prvih konzol, ki je to omogočala. Bili so tudi pionirji na področju 3D videoiger z njihovo konzolo *Nintendo64*.Sčasoma so se bolj posvetili ročnim konzolam, kot so *DS*, *3DS* in sedaj *Switch*.Podjetje dela izključno ekskluzivne igre za svoje konzole.  Kaj lahko povemo o datumu? Med drugim sem zbral podatke o **mesecu** in **letu**, kdaj je katera igra izšla. Sedaj bi se malo poigral s tem. Zanimivo bo videti, katera leta so bila najboljša za videoigre. Prav tako me zanima, če mesec izida kaj vpliva na uspeh iger. Natančneje, ali je med poletnimi počitnicami, ko imajo mladostniki več časa, ali pa decembra, ko starši raje kupijo igre, izdanih več uspešnih iger? Najprej pogljemo leto.<jupyter_code>st_iger_na_leto_dobre = dobre_igre.groupby("leto").size()
st_iger_na_leto_dobre.plot.bar()
st_iger_na_leto_najboljse = najboljse_igre.groupby("leto").size()
st_iger_na_leto_najboljse.plot.bar()<jupyter_output><empty_output><jupyter_text>Prvi graf prikazuje, da je z leti vedno več dobrih iger. Sklepam, da je to enostavno posledaica tega, kako deluje naša metrika.Mi damo namreč velik poudarek na glasovom uporabnikov njihovemu številu. Potem pa vplivajo številni dejavniki, da je več uporabnikov ocenilo igre.Sama stran *Metacritic* je izšla leta 2001, potem pa je gotovo trajalo še nekaj let, da se je prijela in da so ljudje začeli množično podajati svoja mnenja.Poleg tega proizvajalci zadnjih 10 let izvajajo kampanje in ogromne promocije, da širša publika izve za njihove igre.Še ena opazka. 2020 ima manj iger, iz očitnih razlogov. Poleg tega so bili podatki zbrani jeseni, ko večina iger leta še ni izšla.Drugi graf pa pokaže, da je bilo najboljše leto za igre 2011. In če spodaj pogledamo, katere igre so to bile, nas rezultat ne preseneča. *Minecraft*, *Portal*, *The Elder Scrolls V: Skyrim*, pa še marsikaj.<jupyter_code>igre[igre["leto"] == 2011].head(10)<jupyter_output><empty_output><jupyter_text>Poglejmo še, kakšen je vpliv meseca izida na uspeh. Da bomo imeli mesece v običajnem vrstem redu, spišimo spodnji slovar.<jupyter_code>meseci = {"Jan" : 0, "Feb" : 1, "Mar" : 2, "Apr" : 3, "May" : 4, "Jun" : 5,
    "Jul" : 6, "Aug" : 7, "Sep" : 8, "Oct" : 9, "Nov" : 10, "Dec" : 11}
st_iger_na_mesec_dobre = dobre_igre.groupby("mesec").size().sort_index(key = lambda x: x.map(meseci))
st_iger_na_mesec_dobre.plot.bar()
st_iger_na_mesec_najboljse = najboljse_igre.groupby("mesec").size().sort_index(key = lambda x: x.map(meseci))
st_iger_na_mesec_najboljse.plot.bar()<jupyter_output><empty_output><jupyter_text>Zgornja grafa prikazujeta, da je bila moja hipoteza pravilna. Poletni in božični čas vplivata na število dobrih iger, če gledamo dobre igre in najboljše igre nasploh. Presenetljivo je korelacija negativna. Ravno v tem času je izdanih najmanj uspešnih iger. Menim, da je razlog za to naslednji.Videoigre so izredno zahteven medij, kar se tiče proizvodnje, morda celo bolj kot film. Programiranje dejanske igre, snemanje glasov, izdelava grafik. Iskreno sploh ne vem, kaj vse se dogaja v zakulisju. Nekaj pa je jasno, to je drag posel, ki pa lahko vrne ogromen dobiček. Poudarek na lahko. Podjetja zato iščejo investitorje, ki pa gledajo le na denar. Tako kot sem sklepal jaz, tudi oni menijo, da so prazniki in poletno obdobje najboljši čas za prodajo in zato spodbujajo ali zahtevajo, da studii izdajo igre v teh sezonah. Časovna stiska in zahtevnost proizvodnje pomenita, da se v zadnjih mesecih izdelave res hiti. Posledično pride do izdelkov, ki niso tako popolni, kot bi lahko bili. Konkreten primer tega je *Cyberpunk 2077*. To naj bi bila najbolj ambiciozna igra tega desetletja, a je žal ravno iz teh razlogov še ena žrtev leta 2020.  Vpliv oznak Zanima nas, kako **oznake** iger vplivajo na njihov uspeh. Tako kot filmi lahko igre vsebujejo bolj ali manj primerne vsebine. Proizvajalci na to opozorijo z oznako, ki namigne, keterim starostnim skupinam je igra namenjena.Glede na to, da je *Metacritic* ameriška spletna stran, so oznake v mojih podatkih sicer po ameriških standartih, ampak bomo vseeno lahko kaj sklepali. Za lažje razumevanje navajam, kaj katera oznaka pomeni:* **E Everyone** Primerno za vse starosti. Včasih pod oznako **K-A**.  * **E10+ Everyone 10+** Primerno za 10 let in starejše.* **T Teen** Primerno za najstnike oziroma starejše od 13 let.  * **M Mature 17+** Za starejše od 17 let.  * **AO Adults Only** Za starejše od 18 let.   * **RP Rating Pending** Igra še ni ocenjena.  Bolj natančen opis posamezne kategorije je dostopen na strani [*ESRB*](https://www.esrb.org/ratings-guide/).<jupyter_code>oznake_dobre = dobre_igre.groupby("oznaka").size()
oznake_dobre.plot.bar()<jupyter_output><empty_output><jupyter_text>Največ dobrih iger spada v kategoriji *Teen* in *Mature*. Te igre lahko vsebujejo nasilje, kri, kletvice in spolne vsebine. Običajno gre za bolj realistične igre, zato je treba na nasilje primerno opozoriti. Ampak se zdi, da ni tako velike razlike med igrami z bolj lahkotno in bolj zrelo vsebino. Morda kaj več odkrijemo, če pogledamo najboljše igre.<jupyter_code>oznake_najboljse = najboljse_igre.groupby("oznaka").size()
oznake_najboljse.plot.bar()<jupyter_output><empty_output><jupyter_text>Na zgornjem grafu pa izstopa oznaka *M*. Sicer ne želim komentirati, kaj to pomeni, da se najraje ubadamo s takimi vsebinami. Sem pa za šalo pogledal, kaj pravijo podatki za filme s predavanj, in zdi se, da so tudi tam najbolj priljubljeni filmi z oznako *R*, torej tudi primerno za starejše od 17 let. Če morda koga zanima primer "igre za odrasle":<jupyter_code>igre[igre.oznaka == "AO"]<jupyter_output><empty_output><jupyter_text>Vpliv žanra Poglejmo, kaj lahko povemo o **žanru**. Za razliko od filma se ta ne navezuje samo na vsebino zgodbe v igri, ampak tudi na to, kakšne vrste igra je (strelska, dirkalna, platformer ipd.), in kako deluje (v prvi osebi, 3D ali 2D ipd.).<jupyter_code>zanri_dobrih_iger = dobre_igre.merge(zanri)
zanri_dobre = zanri_dobrih_iger.groupby("zanr").size().sort_values(ascending=False).head(15)
zanri_dobre.plot.bar()
zanri_najboljsih_iger = najboljse_igre.merge(zanri)
zanri_najboljse = zanri_najboljsih_iger.groupby("zanr").size().sort_values(ascending=False).head(15)
zanri_najboljse.plot.bar()<jupyter_output><empty_output><jupyter_text>Zdi se, da tako pri dobrih kot najboljših igrah izstopajo podobni žanri.Prevladale so akcijske igre. Spet lahko podoben trend opazimo pri filmih, če se poglobimo v podatke s predavanj.  Morda še nekaj opazk. *Role-Paying* so igre, kjer z dejanji vplivaš na potek zgodbe. Ta torej ni čito določena vnaprej in linearna. Tako se lahko bolj poglobiš v zgodbo in v virtualni svet, ki te obdaja. Zdi se, da je to večini igralcev najbolj pri srcu. Strelske igre so popularne, kar ne preseneča. Morda v oči bode *Western-Style*. Za to sta verjetno odgovorni *Red Dead Redemption* in *Red Dead Redemption 2*, tudi eni izmed najbolj priznanih iger tega desetletja.Pravzaprev nam ti podatki povedo, da čeprav so najuspešnjše igre akcijske, so te v drugih pogledih, kot sta stil ali zgodba, precej raznolike.  Enoigralski ali večigralski  način Sedaj bomo pogledali, ali so bolj uspešne **enoigralske** ali **večigralske** igre. V enoigraskih igrah igraš sam. Običajno gre za bolj zaključene celote s poudarkom na zgodbi, kot film, v katerem lahko sodeluješ. Večigralske igre so po naravi bolj odprte in prava zabava je v tem, da igraš s prijateljem ali proti njemu. Te so igrišča, ki ti omogočajo zabavo na spletu. Zanima nas tudi, ali so bolj uspešne večigralske igre, ko igraš samo z enim prijateljem ali pa vas je več.<jupyter_code>igralski_nacin_dobre = dobre_igre.groupby("stevilo igralcev").size()
igralski_nacin_dobre.plot.bar()
igralski_nacin_najboljse = najboljse_igre.groupby("stevilo igralcev").size()
igralski_nacin_najboljse.plot.bar()<jupyter_output><empty_output><jupyter_text>Odgovor je jasen. Bolj uspešne so enoigralske igre, tako med dobrimi kot najboljšimi. Med večigralskimi pa so boljše tiste, ko naenkrat skupaj igra manj ljudi. Za to vidim nekaj razlogov.* Enoigralske igre so veliko bolj dostopne. Vsakdo se lahko prepusti izkušnji in si pogosto lahko celo prilagodi težavnost. Večigralske igre so veliko bolj zapletene. Preden jih začneš igrati, se moraš ogromno naučiti. Še več dela pa je, da postaneš dober v njih. Zato se je razvila *Esports* scena, to so športna tekmovanja v videoigrah, ki postajajo vedno bolj popularna in posledično so denarne nagrade vedno večje. Nekaj primerov je *Super Smash Bros.*, *League of Legends* ali *Overwatch*.* Ker pri večigralskih igrah prideš v stik z neznanci na spletu, se združita tekmovalnost profesionalnega športa in anonimnost spleta, rezultat pa je lahko res neprijetno okolje. Da se preklinja in zmerja, ni nič nenavadnega. Potrpljenja za novince je malo in od tu prihaja izraz *noob*, ki ga otroci dandanes radi mečejo naokoli. Če je igra namenjena manj igralcem, jo boš verjetno igral s prijatelji in do teh težav ne bo prišlo. Menim, da so zato take igre med večigralskimi bolj uspešne.* Ker so enoigralske igre zaključena celota, jih lahko končaš. To je za nekatere ljudi zelo pomembno. Tako imaš občutek, da si nekaj dosegel, vseeno pa se lahko vrneš k izkušnji in jo igraš od začetka. Večigralske igre pa so narejene tako, da vanje vložiš čim več časa. Sama izkušnja mora biti dovolj zabavna, da se vedno znova vrneš. Večina ljudi preprosto nima časa, da bi si to privoščila.* Zadnja in nekoliko banalna točka. Enoigralsko igro lahko daš na pavzo, večigralske pa ne.  3. Katere igre naj igram? Kot vesten in delaven študent nimam privilegija, da bi čas zapravljal za iskanje videoiger za krajšanje prostega časa, ko bo ta napočil. V ta namem sem pripravil program, ki sprejme seznam **id-jev iger**, ki sem jih že igral, **platforme**, ki so mi na voljo, in **oznake**. Nato vrne priporočila, katere igre bi me morda zanimale. Upošteva naslednje kriterije:* Platforme, ki so mi na razpolago.* Oznake iger, ki jih smem igrati.* Žanr mojih iger.* Besedilo v opisih iger.* Kvaliteto iger po naši metriki.Natančneje:  Program najprej izbere vse primerne kandidate, torej tiste igre, ki so na pravih platformah in imajo pravo oznako, ter odstrani igre, ki smo jih že igrali.  Žanr upoštevamo na sledeč način. Program najprej pogleda podatke iger, ki smo jih že igrali. Za vsak žanr izračuna, kolikšen delež žanrov iger, ki smo jih igrali, je tega žanra. Za dano igro seštejemo pripadajoče deleže njenih žanrov. Tako dobimo utež za žanr, neko število `Uz` med 0 in 1.  Sedaj še opis. Program naredi množico vseh korenov besed, ki se pojavijo v opisih igranih iger. Nato opis vsake igre, če ga ima, razbijemo na korene in pogledamo, kolikšen delež korenov besed tega opisa je v množici. Tako dobimo utež za opis `Uo`.  **Ocena priporočila** je naša prilagojena ocena, obtežena z zgornjima utežema, torej `Op = Po * Uz * Uo`, kjer je `Po` prilagojena ocena. Za obdelavo korenov besed sem si sposodil kodo s predavanj.<jupyter_code>def koren_besede(beseda):
    beseda = ''.join(znak for znak in beseda if znak.isalpha())
    if not beseda:
        return '$'
    konec = len(beseda) - 1
    if beseda[konec] in 'ds':
        konec -= 1
    while konec >= 0 and beseda[konec] in 'aeiou':
        konec -= 1
    return beseda[:konec + 1]

def koreni_besed(niz):
    if type(niz) == str: #Če igra morda nima opisa
        return [koren_besede(beseda) for beseda in niz.lower().split() if len(koren_besede(beseda)) > 2]
    else:
        return []
def priporocene_igre(ze_igrano, platforme, oznake):
    # Maske
    def pomozna_platforma(niz):
        return niz in platforme
    def pomozna_oznaka(niz):
        return niz in oznake
    def pomozna_id(n):
        return n in ze_igrano
    # Kandidati
    kandidati = igre[(igre["platforma"].apply(pomozna_platforma)) & (igre["oznaka"].apply(pomozna_oznaka)) 
                     & (igre["id"].apply(lambda x: not pomozna_id(x)))].copy()
    # Žanr
    def utez_zanr(tabela_iger):
        zanri_igranih = zanri[zanri["id"].apply(pomozna_id)].groupby("zanr").size()
        odstotki_zanri_igranih = (zanri_igranih / zanri_igranih.sum()).to_dict()
        def ujemanje_zanrov(_id):
            zanri_igre = zanri[zanri["id"] == _id].copy()
            def zanr_v_delez(niz):
                if niz in odstotki_zanri_igranih:
                    return odstotki_zanri_igranih[niz]
                else:
                    return 0
            return zanri_igre["zanr"].apply(zanr_v_delez).sum()
        
        tabela_iger["utež žanr"] = tabela_iger["id"].apply(ujemanje_zanrov)
        
    # Opis
    def utez_opis(tabela_iger):
        besede_igranih = set()
        for opis in igre[igre["id"].apply(pomozna_id)]["opis"].tolist():
            besede_igranih.update(koreni_besed(opis))
        def delez_dobrih_besed(niz):
            besede = koreni_besed(niz)
            count = 0
            for beseda in besede:
                if beseda in besede_igranih:
                    count += 1
            return count / (len(besede) + 0.01) # Da ne delimo z 0
        
        tabela_iger["utež opis"] = tabela_iger["opis"].apply(delez_dobrih_besed)
    
    # Ocena priporočila
    def ocena_priporocila(tabela_iger):
        utez_zanr(tabela_iger)
        utez_opis(tabela_iger)
        tabela_iger["ocena priporočila"] = (
            tabela_iger["prilagojena ocena"] * tabela_iger["utež žanr"] * tabela_iger["utež opis"]
        )
        
    ocena_priporocila(kandidati)
    
    return kandidati.sort_values("ocena priporočila", ascending=False).head(15)<jupyter_output><empty_output><jupyter_text>Da lahko program preizkusimo, sem sestavil seznam iger, ki sem jih preigral, ter moje platforme in oznake:<jupyter_code>moje_igre = [143104, 235439, 510872, 113955, 108940, 527417, 204712, 381511, 412871, 297560, 167419, 491138, 231309,
             455529, 455528, 230240, 107838, 109864, 115164, 135708, 110750, 527326, 170232, 477066, 213209, 499153,
             182288, 316002, 510045, 492827, 535703, 109325, 154578, 206739, 114802, 155836, 143153, 491124, 480909]
moje_platforme = ['PC', 'DS']
moje_oznake = ['K-A', 'E', 'E10+', 'M', 'T', 'AO']
priporocene_igre(moje_igre, moje_platforme, moje_oznake)<jupyter_output><empty_output><jupyter_text>Če bralec želi preizkusit program, sta tu seznama vseh platform in oznak. Iz teh lahko odstraniš elemente, ki jih ne potrebuješ, in seznama uporabiš v programu. Prav tako je spodaj "brskalnik", da lažje najdeš id-je igre, ki si jih že igral.Prvi argument naj bo niz, ki nastopi v naslovu igre. Kot drugi neobvezen argument lahko dodaš še platformo.  Veliko zabave želim!<jupyter_code>platforme = ['Nintendo 64', 'PC', 'PlayStation 4', 'PlayStation 3', 'Switch', 'Wii', 'Xbox 360', 'Xbox One', 'PlayStation 2', 
'GameCube', 'PlayStation', 'Xbox', 'Wii U', '3DS', 'PlayStation Vita', 'DS', 'PSP', 'Game Boy Advance', 'Dreamcast' 'Stadia']
oznake = ['K-A', 'E', 'E10+', 'M', 'T', 'AO', 'RP']
def brskalnik(naslov_igre, platforma=None):
    def pomozna_naslov(niz):
        return naslov_igre in niz
    def pomozna_platforma(niz):
        return True if platforma is None else platforma == niz
    return igre[
        (igre["naslov"].apply(pomozna_naslov)) & (igre["platforma"].apply(pomozna_platforma))
               ].sort_values("prilagojena ocena", ascending=False)
brskalnik("Assassin's Creed", "PC")<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.08071612291864086, 'fraction_numerical': 0.014518749153919047, 'mean_word_length': 5.078790372351368, 'pattern_counts': {'":': 1, '<': 127, '<?xml version=': 0, '>': 129, 'https://': 1, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '31', 'dir': 'jupyter-structured-clean-dedup', 'id': '49877', 'license': 'MIT', 'n_tokens_mistral': 12488, 'n_tokens_neox': 12110, 'n_words': 3552, 'path': 'Najboljse_videoigre_vseh_casov.ipynb', 'repo_name': 'benoucakar/analiza-podatkov---Najbolj-ih-10000-videoiger', 'size': '29548'}