def izloci_podatke_receptov(imenik):
recepti = []
for html_datoteka in orodja.datoteke(imenik):
for recept in re.finditer(regex_recepta,
orodja.vsebina_datoteke(html_datoteka)):
recepti.append(pocisti_recept(recept))
return recepti
def get_cvs():
regex_competitors = re.compile(
r'<tr.*?><td><a href="participant_r\.aspx\?id=(?P<id>\d+?)">(?P<Name>.*?)</a>.*?'
r'href="country_individual_r\.aspx\?code=(?P<Short_country_name>.*?)">(?P<Full_country_name>.*?)</a>.*?'
r'align="center">(?P<P1>.*?)</td><td align="center">(?P<P2>.*?)</td><td align="center">(?P<P3>.*?)</td>'
r'<td align="center">(?P<P4>.*?)</td><td align="center">(?P<P5>.*?)</td><td align="center">(?P<P6>.*?)</td>'
r'<td align="right">(?P<Points>.*?)</td><td align="right">(?P<Rank>.*?)</td><td>(?P<Achievement>.*?)</td></tr>',
flags=re.DOTALL)
matchings = []
for year in orodja.datoteke('podatki'):
for cats in re.finditer(regex_competitors,
orodja.vsebina_datoteke(year)):
cat = cats.groupdict()
cat['id'] = int(cat['id'])
for i in range(1, 7):
name = 'P{}'.format(i)
cat[name] = int(cat[name])
cat['Points'] = int(cat['Points'])
cat['Rank'] = int(cat['Rank'])
cat['Year'] = int(os.path.split(year)[1])
matchings.append(cat)
orodja.zapisi_tabelo(matchings, [
'id', 'Name', 'Short_country_name', 'Full_country_name', 'P1', 'P2',
'P3', 'P4', 'P5', 'P6', 'Points', 'Rank', 'Year', 'Achievement'
], 'data.csv')
def izloci_podatke_aplikacij(imenik):
aplikacije = []
for html_datoteka in orodja.datoteke(imenik):
for aplikacija in re.finditer(regex_aplikacije,
orodja.vsebina_datoteke(html_datoteka)):
aplikacije.append(pocisti_aplikacijo(aplikacija))
return aplikacije
def izloci_podatke_gora(imenik):
regex_gore = re.compile(
r'<td class="naslov1"><b> <h1>(?P<ime>.*?)</h1></b></td>.*?'
r'<tr><td><b>Država:</b> <a class=moder href=/gore/.+?/\d>(?P<država>.*?)</a></td></tr>.*?'
r'<tr><td><b>Gorovje:</b> <a class="moder" href="/gorovje/.*?/\d{1,3}">(?P<gorovje>.*?)</a></td></tr>.*?'
r'<tr><td><b>Višina:</b> (?P<višina>\d+?) m</td></tr>.*?'
r'<tr><td><b>Širina/Dolžina:</b> <a class="moder" href="/zemljevid\.asp\?goraid=(?P<id>\d*?)">.*?'
r'<tr><td><b>Vrsta:</b> (?P<vrsta>.*?)</td></tr>.*?'
r'<tr><td><b>Ogledov:</b> (?P<st_ogledov>\d*?)</td></tr>.*?'
r'<tr><td><b>Priljubljenost:</b> \d+% \((?P<priljubljenost>\d+). mesto\)</td></tr>.*?'
r'<tr><td><b>Število poti:</b> <a class="moder" href="#poti">(?P<st_poti>\d*?)</a></td></tr>.*?'
r'<tr><td><b>Število GPS sledi:</b> <a class="moder" href="/gps.asp">(?P<st_GPS_sledi>\d+)</a></td></tr>.*?'
r"href='/izlet/.*?'>(?P<nakljucna_pot>.*?) .*?</a></td><td><a.*?"
r"href='/izlet/.*?>(?P<cas_hoje>.*?)</a></td><td><a.*?"
r"href='/izlet/.*?'>(?P<zahtevnost_poti>.*?)</a></td><td>.*?",
flags=re.DOTALL)
gore = []
for html_datoteka in orodja.datoteke(imenik):
for gora in re.finditer(regex_gore,
orodja.vsebina_datoteke(html_datoteka)):
gore.append(pocisti_goro(gora))
print(gore)
orodja.zapisi_tabelo(gore, [
'ime', 'država', 'gorovje', 'višina', 'id', 'vrsta', 'st_ogledov',
'priljubljenost', 'st_poti', 'st_GPS_sledi', 'nakljucna_pot',
'cas_hoje', 'zahtevnost_poti'
], 'gore.csv')
def izloci_podatke_kategorij(imenik):
kategorije = []
for html_datoteka in orodja.datoteke(imenik):
for kategorija in re.finditer(regex_kategorije,
orodja.vsebina_datoteke(html_datoteka)):
kategorije.append(pocisti_kategorije(kategorija))
return kategorije
def izloci_podatke(imenik):
potresi = []
for html_datoteka in orodja.datoteke(imenik):
for potres in re.finditer(regex_potresa,
orodja.vsebina_datoteke(html_datoteka)):
potresi.append(pocisti(potres))
return potresi
def izloci_rezultate(imenik, regex):
'''Vrne seznam s slovarji podatkov iz imenika'''
podatki = []
for datoteka in orodja.datoteke(imenik):
for podatek in re.finditer(regex, orodja.vsebina_datoteke(datoteka)):
pod = podatek.groupdict()
pod['Leto'] = int(pod['Leto'])
podatki.append(pod)
return podatki
def izloci_podatke_rezultati(imenik):
'''Poišče ujemanja med regexom rezultatov in datotekami v imeniku in jih vrne v obliki seznama.'''
ujemanja = []
for datoteka in orodja.datoteke(imenik):
print(datoteka)
vsebina = orodja.vsebina_datoteke(datoteka)
for podatki in re.finditer(regex_rezultatov, vsebina):
ujemanja.append(pripravi_podatke_rezultati(podatki))
print(ujemanja)
return ujemanja
def izloci_podatke_potresov():
regex_potresa = re.compile(
r'<a href=".+?\.php\?id=(?P<id>\d{6})">(?P<leto>\d{4})-(?P<mesec>\d{2})-(?P<dan>\d{2}).+?(?P<ura>\d{2}:\d{2}:\d{1,2})\.\d</a>.+?'
r'<td class="tabev1">(?P<sirina>\d{1,2}\.\d{1,2}) </td><td class="tabev2">[NS].+?'
r'<td class="tabev1">(?P<dolzina>\d{1,2}\.\d{1,2}) </td><td class="tabev2">[EW].+?'
r'<td class=\"tabev\d\">(?P<globina>\d{1,3})<\/td>.+?'
r'<td class=\"tabev\d\">(?P<magnituda>\d\.\d)<\/td>.?'
r'<td id="reg\d+" class="tb_region" > (?P<drzava>.+?)<\/td>',
flags=re.DOTALL)
for html_datoteka in orodja.datoteke('strani/'):
for potres in re.finditer(regex_potresa,
orodja.vsebina_datoteke(html_datoteka)):
print(potres.group('magnituda'), potres.group('drzava'))
def pripravi_aplikacije():
regex_aplikacije = re.compile(
r'<a href="/application/(?P<povezava>.+?)?hl=en">(?P<ime>.+?)</a>',
flags=re.DOTALL)
for html_datoteka in orodja.datoteke('aplikacije/'):
for aplikacija in re.finditer(regex_aplikacije,
orodja.vsebina_datoteke(html_datoteka)):
naslovcek = '{}{}'.format(
'http://www.androidrank.org/application/',
aplikacija.group('povezava'))
imencek = 'app/{}.html'.format(aplikacija.group('ime'))
orodja.shrani(naslovcek, imencek)
def zajemi_isbn():
regex_isbn=re.compile(
r'gp/product-reviews/(\d{10}).{150,200}?\$\d*\.\d{2} \$(\d*\.\d{2})',
flags=re.S
)
seznamISBN=[]
for html_datoteka in orodja.datoteke('podatki/amazon/'):
for knjiga in re.finditer(regex_isbn, orodja.vsebina_datoteke(html_datoteka)):
seznamISBN.append(knjiga.group(1))
return seznamISBN
def priprava_amazon():
regex_knjige = re.compile(
r'gp/product-reviews/(?P<ISBN10>\d{10}).{150,200}?\$\d*\.\d{2} \$(?P<cenaD>\d*\.\d{2})',
flags=re.S
)
knjige = {}
for html_datoteka in orodja.datoteke('podatki/amazon5/'):
for knjiga in re.finditer(regex_knjige, orodja.vsebina_datoteke(html_datoteka)):
podatki=knjiga.groupdict()
knjige[podatki['ISBN10']]=podatki
orodja.zapisi_tabelo(sorted(knjige.values(), key=lambda knjiga: knjiga['ISBN10']),
['ISBN10','cenaD'], 'csv-datoteke/amazon2.csv')
def pripravi_bwin(potdatoteke = datum):
reg_sportnika = re.compile(r'<td class="option option_(.*?)" >'
r'[^я]*?<span class="option-name">(?P<sportnik>.*?) \((?P<drzava>.*?)\)</span>'
r'[^я]*?<span class="odds">(?P<kvota>.*?)</span>')
reg_dogodka = re.compile(r'.*<a class="league-link" href=".*" >(?P<dogodek>.*.)\n* *- (?P<drzava>.*)</a>')
#r'.*<a class="league-link" href=".*" >(?P<dogodek>.*.\n.*)</a>')
reg_datumi = re.compile(r'(?P<vse><h2 class="event-group-level3">[^Я]*? *.* - (?P<datum>.*)[^Я]*?<div class="ui-widget-content-body)')
###############################################################
#Tole je preveč. Treba je iti korak za korakom. #
###############################################################
#reg_datumi = re.compile(r'<h2 class="event-group-level3">[^Я]*? *.* - (?P<datum>.*)[^Я]*?</h2>'
# r'[^Я]*?<a class="league-link" href="(.*)[^Я]*? - (?P<kategorija>.*)</a>'
# r'[^Я]*?<h6 class="event-info">[^Я]*? *(?P<kraj>.*)[^Я]*?<td class="option option_'
# r'(.*?)" >'
# r'[^я]*?<span class="option-name">(?P<sportnik>.*?).\((?P<drzava>.*?)\)</span>'
# r'[^я]*?<span class="odds">(?P<kvota>.*?)</span>'
# r'[^я]*</html>')
reg_celatabela = re.compile(
r'<a class="league-link" href=".*" >(?P<dogodek>[^Я]*?)</a>[^я]*?<span class="option-name">'
r'(?P<sportnik>.*?) \((?P<drzava>.*?)\)</span>[^Я]*?<span class="odds">(?P<kvota>.*)'
r'</span>[^я]*?(<a class="league-link" href=|<div class="ui-widget-content" id="sport-footer">)'
)
igralci_surovo = []
dogodki = []
igralci = []
kategorije = []
for html_datoteka in orodja.datoteke('zajete-strani/' + potdatoteke + '/bwin/'):
datoteka = 'zajete-strani/' + potdatoteke + '/' + html_datoteka
csvDat = 'csv-datoteke/'+ html_datoteka[13:-5]
for ujemanje in re.finditer(reg_datumi, orodja.vsebina_datoteke(html_datoteka)):
#print(uredi_datum(ujemanje.group('vse'), ujemanje.group('datum')))
#print(ujemanje.groupdict())
if uredi_datum(ujemanje.group('vse'), ujemanje.group('datum')) != {}:
kategorije += [uredi_datum(ujemanje.group('vse'), ujemanje.group('datum'))]
orodja.zapisi_tabelo(kategorije, ['datum', 'kategorija'], csvDat + '/kategorije.csv')
for ujemanje in re.finditer(reg_celatabela, orodja.vsebina_datoteke(html_datoteka)):
igralci += [ujemanje.groupdict()]
orodja.zapisi_tabelo(igralci, ['dogodek', 'kvota', 'drzava','sportnik'], csvDat + '/sportniki.csv')
for ujemanje in re.finditer(reg_dogodka, orodja.vsebina_datoteke(html_datoteka)):
dogodki += [ujemanje.groupdict()]
orodja.zapisi_tabelo(dogodki, ['dogodek', 'drzava'], csvDat + '/dogodki.csv')
#
for ujemanje in re.finditer(reg_sportnika, orodja.vsebina_datoteke(html_datoteka)):
#print(ujemanje.groupdict())
igralci_surovo += [ujemanje.groupdict()]
orodja.zapisi_tabelo(igralci_surovo, ['sportnik', 'drzava', 'kvota'], csvDat + '/sportniki_surovo.csv')
def pripravi_nba():
regex_nba = re.compile(
r'<a href="http://www.espn.com/nba/player/_/id/(?P<id>\d+)/.*?>(?P<igralec>.*?)</a>.*?align="left">(?P<ekipa>.*?)</td><td >(?P<odigrane_igre>\d+)</td><td >(?P<minute_natekmo>.*?)<.*?class="sortcell">(?P<točke_na_tekmo>.*?)<.*?/td><td >.(?P<met_iz_igre>\d+)<.*?</td><td >.(?P<trojke>\d+)<.*?</td><td >.(?P<prosti_meti>\d+)<.*?>',
flags=re.DOTALL)
#<a href="http://www.espn.com/nba/player/_/id/6583/anthony-davis">Anthony Davis</a>, PF</td><td align="left">NO</td><td >37</td><td >37.1</td><td class="sortcell">29.1</td><td >10.5-21.2</td><td >.496</td><td >0.6-1.9</td><td >.300</td><td >7.6-9.5</td><td >.796</td></tr><tr class="evenrow player-46-3992" align="right"><td align="left">3</td><td align="left">
pojavitve = []
for html_datoteka in orodja.datoteke('StatLeaders1617/'):
vsebina = orodja.vsebina_datoteke(html_datoteka)
for pojavitev in re.finditer(regex_nba, vsebina):
pojavitve.append(zbrisi_pojavitev(pojavitev))
orodja.zapisi_tabelo(pojavitve, [
'id', 'igralec', 'ekipa', 'odigrane_igre', 'minute_natekmo',
'točke_na_tekmo', 'met_iz_igre', 'trojke', 'prosti_meti'
], 'pojavitve7.csv')
def izloci_podatke_piv(imenik, regex):
'''Iz html datotek izloči podatke piv'''
podatki = []
for datoteka in orodja.datoteke(imenik):
pivo = re.search(regex, orodja.vsebina_datoteke(datoteka))
if pivo is not None:
pod = pivo.groupdict()
if pod['Price'] is None:
pod['Price'] = 'Discontinued'
else:
pod['Price'] = float(pod['Price'])
pod['id'] = int(pod['id'])
pod['Description'] = str(pod['Description']).replace('\\"', '')
pod['Description'] = str(pod['Description']).replace(';', ',')
podatki.append(pod)
else:
print(datoteka)
return podatki
def izloci_podatke_vin(imenik, regex):
'''Iz html datotek izloči podatke vin'''
podatki = []
for datoteka in orodja.datoteke(imenik):
vino = re.search(regex, orodja.vsebina_datoteke(datoteka))
if vino is not None:
pod = vino.groupdict()
pod['Price'] = float(pod['Price'])
pod['id'] = int(pod['id'])
vrste = regex_vrsta.findall(pod['Varietal'])
pod['Varietal'] = vrste
pod['Description'] = str(pod['Description']).replace('\n', '')
if pod['ABV'] != 'N/A':
pod['ABV'] = float(pod['ABV'])
else:
pod['ABV'] = None
podatki.append(pod)
else:
print(datoteka)
os.remove(datoteka)
return podatki
def priprava_depository():
regex_knjige = re.compile(
r'<meta itemprop="author" content="(?P<avtor>.*?)".*?'
r'<h1 itemprop="name">(?P<naslov>.*?)<.*?'
r'<div class="item-info-wrap">\s*<p class="price">\s*(?P<cenaE>\d*,\d{2}).*?'
r'<label>Format</label>\s*<span>\s*(?P<format>\w*).*?'
r'"numberOfPages">(\d+).*?"datePublished">(?P<datum>\d{2} \w{3} \d{4}).*?'
r'Language</label>\s*<span>\s*(?P<jezik>\w*).*?'
r'ISBN10</label>\s*<span>(?P<ISBN10>\d{10}).*?'
r'ISBN13</label>\s*<span itemprop="isbn">(?P<ISBN13>\d{13})',
flags=re.S
)
knjige = {}
for html_datoteka in orodja.datoteke('podatki/depositoryISBN/'):
for knjiga in re.finditer(regex_knjige, orodja.vsebina_datoteke(html_datoteka)):
podatki=knjiga.groupdict()
knjige[podatki['ISBN10']]=podatki
orodja.zapisi_tabelo(sorted(knjige.values(), key=lambda knjiga: knjiga['ISBN10']),
['ISBN10','avtor', 'naslov', 'cenaE', 'format','jezik','datum','ISBN13'],
'csv-datoteke/depository2.csv')
def izloci_podatke_filmov(imenik):
filmi = []
for html_datoteka in orodja.datoteke(imenik):
for film in re.finditer(regex_filma, orodja.vsebina_datoteke(html_datoteka)):
filmi.append(pocisti_film(film))
return filmi
import zajemi_podatke as zp
import delamo_csv as dc
import delamo_csv_avtor as dca
import delamo_csv_serija as dcs
import delamo_csv_zanr as dcz
import delamo_csv_kljucne_besede as dckb
import orodja
seznam_vseh_tujih_knjig = []
zp.zajemi_knjige()
# v mapo knjige shrani knjige s seznama (z vseh strani naceloma)
mapa_knjige = orodja.datoteke("knjige")
print('shranjujem knjige')
dc.shrani_knjige(mapa_knjige)
seznam_vseh_tujih_knjig += dc.seznam_tujih_knjig
# ~~~~~~~~~~~~~ sedaj se generirajo te zadeve:~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# PODATKI ZA ZAPIS: (nekoncni)
# seznam_vseh_knjig vsebuje vse, kar potrebujemo za zapis knjig s seznama v csv tabelo
# seznam_avtor_knjiga vsebuje podatke avtor-knjiga za zapis te relacije
# seznam_zanr_knjiga vsebuje podatke zanr-knjiga za zapis te relacije
# seznam_serija_knjiga vsebuje podatke serija-knjiga-stevilka za to relacijo
#
# Pomoc:
# idji_knjig - shranjuje samo id-je knjig na goodreadsu, da ne zajemava dvakrat knjig kasneje pri serijah.
#
# PODATKI ZA NADALJNI ZAJEM:
# slovar_url_serij vsebuje url naslove spletnih strani za zajem ostalih knjig v seriji
# slovar_url_avtorjev vsebuje url naslove spletnih strani za zajem podatkov o avtorjih
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ do tu~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def pripravi_bwin(potdatoteke = datum):
regex_celatabela = re.compile(
r'(?P<vse>.*<a class="league-link" href=".*" >(?P<ime_dogodka>.*.)\n *- (?P<drzava>.*)</a>'
r'[^я]*?<span class="option-name">(?P<igralec>.*)</span>\n *<span class="odds">(?P<kvota>.*)</span>'
r'[^я]*?(<a class="league-link" href=|<div class="ui-widget-content" id="sport-footer">))'
)
regex_celatabela1 = re.compile(
r'(?P<vse>.*<a class="league-link" href=".*" >(?P<ime_dogodka>.*.)\n *- (?P<drzava>.*)</a>'
r'[^я]*?<span class="option-name">(?P<igralec>.*)</span>\n *<span class="odds">(?P<kvota>.*)</span>'
r'[^я]*?(<a class="league-link" href=|<div class="ui-widget-content" id="sport-footer">))'
)
regex_dogodka1 = re.compile(
r'.*<h6 class="game">(?P<dogodek>.*)</h6>'
r'[^я]<h6 class="game">'
#r'.*<a class="league-link" href=".*" >(?P<dogodek>.*.\n.*)</a>'
)
regex_dogodka1 = re.compile(
r'.*<a class="league-link" href=".*" >(?P<dogodek>.*.)\n* *- (?P<drzava>.*)</a>'
r''
#r'.*<a class="league-link" href=".*" >(?P<dogodek>.*.\n.*)</a>'
)
regex_sporta = re.compile(
r'<button type="submit" class="no-uniform option-button fav-button">\n* *<span class="option-name">'
r'(?P<ime>.*)</span>\n* *<span class="odds">(?P<kvota>.*)</span>')
dogodek, igralec = {}, {}
drzava, kvota = set(), []
podatki_dogodkov = {}
j = 1
i = 1
kvot = 0
print(orodja.datoteke(potdatoteke + '/bwin/'))
for html_datoteka in orodja.datoteke(potdatoteke + '/bwin/'):
#print(orodja.vsebina_datoteke(html_datoteka))
for tabela in re.finditer(regex_celatabela, orodja.vsebina_datoteke(html_datoteka)):
print('***')
#print(tabela)
for podatki in re.finditer(regex_celatabela, tabela.group('vse')):
#for dogodek in re.finditer(regex_dogodka, tabela.group('vse')):
#dogodek = podatki.group('dogodek')
dogodek = tabela.group('ime_dogodka')
igralec = tabela.group('igralec')
print(dogodek)
print(podatki)
print(igralec + tabela.group('kvota'))
podatki_dogodka = podatki_dogodkov.get(dogodek, {})
podatki_dogodka[tabela.group('igralec')] = tabela.group('kvota')
podatki_dogodkov[dogodek] = podatki_dogodka
#drzava.add(podatki.group('drzava'))
#print(podatki.group('dogodek') + ' -- ' + podatki.group('igralec') + ' -- ' + podatki.group('kvota'))
#for html_datoteka in orodja.datoteke(potdatoteke + '/bwin/'):
# print(html_datoteka)
# for ime in re.finditer(regex_dogodka, orodja.vsebina_datoteke(html_datoteka)):
# if ime.group('drzava') == 'Slovenia':
# pass
#print(ime.group('dogodek') + ' ' + ime.group('drzava') + ' ' + html_datoteka)
# j += 1
for html_datoteka in orodja.datoteke(potdatoteke + '/bwin/'):
for ime in re.finditer(regex_sporta, orodja.vsebina_datoteke(html_datoteka)):
#print(ime.group('ime') + ' ' + ime.group('kvota') + ' ' + datum[14:-1])
i += 1
kvot += float(ime.group('kvota'))
orodja.zapisi_tabelo(igralec.values(), ['igralec', 'kvota'], 'csv-datoteke/dogodki.csv')
print(drzava)
print(igralec)
return (i, j, kvot/i)
regex=re.compile(
r'},"name":"(?P<naslov>.*?)".*?'
r'"blurb":"(?P<povzetek>.*?)".*?'
r'"goal":(?P<cilj>.*?)\.0,"pledged":(?P<pridobljen_denar>.*?)\.\d.*?'
r'"country":"(?P<drzava>\D*?)".*?'
r'"backers_count":(?P<st_backerjev>.+?),".*?'
r'"creator":{"id":\d+?,"name":"(?P<avtor>.*?)".*?'
r'"category":{"id":\d+?,"name":"(?P<kategorija>.*?)".*?'
,
flags=re.DOTALL
)
projekti = []
for datoteka in orodja.datoteke('strani_projektov/'):
for ujemanje in re.finditer(r'window\.current_project(?P<iskanje>.*?)www\.kickstarter\.com/discover/categories',orodja.vsebina_datoteke(datoteka)):
iskalni_niz = ujemanje.groupdict()['iskanje']
for projekt in re.finditer(regex,iskalni_niz):
projekti.append(projekt.groupdict())
def pocisti_str(besedilo):
besedilo = besedilo.replace(r''','\'')
besedilo = besedilo.replace(r'&','&')
besedilo = besedilo.replace('\\\\n','')
return(besedilo)
for projekt in projekti:
import re
import orodja
for stran in range(1,101):
naslov_glavni = 'https://www.kickstarter.com/discover/advanced?&sort=end_date'
polni_naslov='{}&page={}'.format(naslov_glavni,stran)
ime_datoteke = 'strani_seznamov_projektov/{:02}.html'.format(stran)
orodja.shrani(polni_naslov,ime_datoteke)
spletni_naslovi_projektov=set()
for datoteka in orodja.datoteke('strani_seznamov_projektov/'):
naslovi_projektov=set()
vsebina=orodja.vsebina_datoteke(datoteka)
for naslov in re.finditer(r'href="/projects/(?P<spletni_naslov>.+)\?.*?',vsebina):
spletni_naslovi_projektov.add(naslov.groupdict()['spletni_naslov'])
print(spletni_naslovi_projektov)
print(len(spletni_naslovi_projektov))
with open('spletni_naslovi_projektov', 'w+') as datoteka:
for naslov_projekta in spletni_naslovi_projektov:
datoteka.write(naslov_projekta+'\n')
def izbrisi_neobstojece():
'''Izbriše datoteke neobstoječih dirk'''
for datoteka in orodja.datoteke('rezultati/'):
if 'Results for this race are not available' in orodja.vsebina_datoteke(datoteka):
os.remove(datoteka)
def izloci_podatke_filmov(imenik):
filmi = []
for html_datoteka in orodja.datoteke(imenik):
for film in re.finditer(regex_filma, orodja.vsebina_datoteke(html_datoteka)):
filmi.append(pocisti_film(film))
return filmi
def naredi_csv_datoteke():
sahisti = []
for html_datoteka in orodja.datoteke('lista/'):
for sahist in re.finditer(sahist_regex, orodja.vsebina_datoteke(html_datoteka)):
sahisti.append(pocisti_sahisti(sahist))
return sahisti
nimek = ''
for priimek in imek.split(sep = '-'):
priimek = priimek[0] + priimek[1:].lower()
nimek += '-' + priimek
nime += ' ' + nimek[1:]
return nime[1:]
def povprecje(a,b):
# izracuna povprečje dveh števil, ki sta podani kot niz, drugi je
# lahko prazen niz, in vrne niz v katerem je zapisano število
if b == '':
return a
return str((float(a) + float(b))/2)
########## Ta del kode ustvari csv datoteke ##################
tekme = orodja.datoteke('podatki/tekme')
idtekme = re.compile(r'<input type="hidden" name="raceid" id="raceid" value="(?P<id_tekme>\d{4})"/>')
vzorec_tekme = re.compile(r'<div class="padding-content">\s*<h3>\s*.*?<a href='\
r'".*?place=(?P<id_prizorisca>.*?)&gender=.*?">(?P<prizorisce>.*?)</a>\s*\((?P<drzava>\w{3})\)\s*<.*?">(?P<datum>\d\d\.\d\d.\d\d\d\d)</span>[\S\s]*?'
r'<div class="right text-right">Race codex')
vzorec_tekmovalca = re.compile(r'<td class=.i\d. align=.right.> (?P<uvrstitev>([12]?\d)|(30))</td>\s'\
r'<td .*?</td>\s'\
r'<td class=.i\d. align=.right.> (?P<id_tekmovalca>\d+?)</td>\s'\
r'<td class=.i\d.><a href=".*?">(?P<ime>.*?)</a> </td>\s'\
r'<td class=.*?>(?P<letnica>\d+?) </td>\s'\
r'<td class=.*?>(?P<nacionalnost>\w+?) </td>\s'\
r'<td class=.*?> (?P<dolzina1>.*?)</td>\s'\
r'<td .*?</td>\s<td class=.*?> (?P<dolzina2>.*?)</td>\s'\
r'<td .*?</td>\s<td class=.*?> (?P<tocke>.*?)</td>')
'British Literature': '',
'Ireland': '',
'Russia': '',
'Glbt': 'Lgbt',
'North American Hi...': 'Historical',
'Kids': 'Childrens',
'Sci Fi Fantasy': 'Science Fiction',
'Teen Fiction': 'Teen',
'Social Sciences': 'Sociology',
'Ya Fantasy': 'Young Adult Fantasy',
'Dystopian': 'Dystopia',
'Fanfiction': 'Fan Fiction',
'Children\'s, Young Adult': 'Childrens'
}
mapa = orodja.datoteke("zanri")
def shrani_zanre(mapa):
for zanr in mapa:
print(zanr)
vsebina = orodja.vsebina_datoteke(zanr)
podatki2 = {'opis': None}
for vzorec1 in re.finditer(vzorec_ime_zanra, vsebina):
podatki1 = vzorec1.groupdict()
for vzorec2 in re.finditer(vzorec_opis_zanr, vsebina):
podatki2 = vzorec2.groupdict()
if podatki2['opis_dolg'] is None: #Opis je takratek
podatki2['opis'] = orodja.pocisti_niz(
html.unescape(podatki2["opis"]))
def izloci_podatke_knjig(imenik):
knjige = []
for html_datoteka in orodja.datoteke(imenik):
for knjiga in re.finditer(regex_knjige, orodja.vsebina_datoteke(html_datoteka)):
knjige.append(pocisti_knjige(knjiga))
return knjige
