Megmutatjuk, hogy önálló Python scriptek hogyan kezelik a bemeneti paramétereiket és hogyan tudunk fájlokat írni és olvasni
A Python a fájlokat egy fájl objektumon keresztül olvassa és írja:
Az open(filename[, mode]) függvény egy fájlobjektumot ad vissza, ahol a mode lehet 'r' (read, olvasás), 'w' (write, írás), 'r+' (mindkettő), 'a' (append, hozzáírás), 'a+' (append+read) vagy bináris fájlokra 'rb', 'wb', 'r+b', 'ab', 'a+b'.
f = open('E0.csv') # megnyitja olvasásra, visszaad egy file-objektumot
print(f)
print(type(f))
Egyelőre ez csak egy fájl objektum. A mintafájlunk az angol Premier League 2015/16-os idényének a statisztikáit tartalmazza. Most olvassunk is valamit! Az read() metódus kiolvassa a fájl teljes tartalmát egy sztringbe. Nem printeljük ki az egészet, mert túl nagy, csak az első 100 karaktert.
f = open('E0.csv')
content = f.read()
print(content[:100])
Olvassuk ki most csak az első sort! Ehhez használhatjuk a readline() metódust.
f = open('E0.csv')
first_line = f.readline()
print(first_line)
second_line = f.readline()
print(second_line)
Még egyszerűbb lehetőséget nyújt, hogy a fájl objektum soronként iterálható.
Figyeljük meg, hogy újsor karakter van minden sor végén.
f = open('E0.csv')
lst = []
for line in f:
lst.append(line)
print(lst[:4])
Az lst lista a fájl sorait tartalmazza. A sorokat .split(",")-tel cellákká is tudjuk tördelni, de erről mindjárt részletesebben.
Képzeljük el, hogy Liverpool szurkolók vagyunk és nekünk csak a kedvenc csapatunk eredményei számítanak. Írjuk ki egy fájlba őket! Az olvasáshoz hasonlóan szükségünk lesz egy fájl objektumra, de ahhoz, hogy írni tudjuk, másként kell megnyitni. Először egy egyszerű példa. Az open(filename, 'w') írásra nyitja meg a fájlt, de ha írunk, vigyázzunk, hogy zárjuk is be!
f = open('Liverpool.csv', 'w')
f.write('YNWA') # You'll Never Walk Alone
f.close()
Vagy egy ekvivalens megoldás a with paranccsal, amely után nem szükséges használni a close() metódust, mert a with hatóköréből kilépve azt bezárja. Olvashatóbb, biztonságosabb kódot eredményez:
with open('Liverpool.csv', 'w') as f:
f.write('When you walk through a storm\n')
Addjunk hozzá a már lezárt fájlhoz még egy sort:
with open('Liverpool.csv', 'a') as f:
f.write('Hold your head up high\n')
Megjegyzés: szöveges fájl olvasásához az open('E0.csv', 'r') parancsot használjuk, de alapértelmezésben olvasásra nyitunk meg egy fájlt, ezért az r elhagyható.
Térjünk vissza az eredeti példához! Soronként beolvassuk a fájlt, és azt a sort, ahol a 'Liverpool' szó szerepel, elmentjük. Ne felejtsük el, hogy a fejlécre továbbra is szükségünk van!
f = open('E0.csv')
lst = [f.readline()] # fejléc
for line in f:
if 'Liverpool' in line:
lst.append(line)
with open('Liverpool.csv', 'w') as f:
for l in lst:
f.write(l)
Írjunk ki néhány számot bájtokban, majd olvassuk vissza!
with open("binfile.bin", "wb") as f:
numbs = [1, 2, 4, 8, 16, 32, 31]
arr = bytearray(numbs)
f.write(arr)
with open("binfile.bin", "rb") as f:
numbs = list(f.read())
print(numbs)
csv fájl kezelése Pythonban¶Az előző fájl .csv kiterjesztése a comma separated values-ra utal (ld. Wikipedia). Az ilyen fájlok egyszerű szövegfájlok, melyek egy sorában egy rekord szerepel, a rekordok adatait pedig vesszővel – választhatunk más karaktert, pl. tab, pontosvessző stb. – választjuk el. Ilyen formátumba menthetők a táblázatkezelők (pl. Excel, libreoffice,...) által kezelt táblázatok. Pythonnal könnyű kezelni az ilyen fájlokat (ld. a Python dokumentációban). Erre való a csv modul.
import csv
l = []
with open('E0.csv', 'r') as csvfile:
reader = csv.reader(csvfile) #, delimiter=',', quotechar='"')
for row in reader:
l.append(row)
print(l[0])
print(l[19])
A különbség szembetűnő. A csv.reader() egyből listát csinál nekünk a sorokból. Ráadásul megadhatjuk neki az elválasztó karaktert a delimiter opcióval, valamint a fájlban használt idézőjel karaktert a quotechar opcióval. Ez azért fontos néhány esetben, mert sokszor számok és sztringek vegyesen vannak egy csv fájlban, ilyenkor a sztringeket idézőjelbe szokták tenni, amit a csv modul felismer és nem nekünk kell foglalkozni vele.
Ha jól megnézzük az adatokat, nekünk nem feltétlenül listákra lenne szükségünk, hanem szótárakra. A fájl ugyanis minden meccsre ugyanazokat az adatokat tárolja, mi pedig szívesebben hivatkozunk indexek helyett nevekkel dolgokra. Erre is van lehetőség.
import csv
l = []
with open('E0.csv') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
l.append(row)
print(l[0])
Nem azt kaptuk, amire számítottunk: az OrderedDict, azaz a rendezett szótár a dict osztály alosztálya, amely a létrehozás sorrendjét is jegyzi, ellentétben a szokásos szótárral. Egyébként a rendezett szótárakra ugyanazok a metódusok használhatók, mint a szótárakra. Szótárként való kiírásuk így történhet:
print(dict(l[0]))
Egy kis kitérő: ha rendezett szótárat akarunk létrehozni, kezelni, be kell tölteni a collections modult (itt most nem kellett, a csv megtette). Az alábbi példa azt mutatja, hogy a rendezett szótárak összehasonlításánál számít a létrehozás sorrendje:
import collections
d1 = {}
d1['x'] = 'X'
d1['y'] = 'Y'
d2 = {}
d2['y'] = 'Y'
d2['x'] = 'X'
print(d1 == d2)
d1 = collections.OrderedDict()
d1['x'] = 'X'
d1['y'] = 'Y'
d2 = collections.OrderedDict()
d2['y'] = 'Y'
d2['x'] = 'X'
print(d1 == d2)
Tároljuk most el a Liverpool mérkőzéseinek legfontosabb adatait. Ezek a 'Date', 'HomeTeam', 'AwayTeam', 'FTHG' (Full Time Home Goals), 'FTAG' (Full Time Away Goals), 'FTR' (Full Time Result)! A tároláshoz a csv.DictWriter lesz segítségünkre. A writeheader() metódus a fejlécet írja ki fájlba, a writerows() pedig egy mozdulattal kiírja az összes adatunkat. A fieldnames paraméterben adhatjuk meg, hogy milyen attribútumokra van szükségünk, az extrasaction='ignore' pedig pusztán azért kell, hogy a többi adatot ne írja bele.
import csv
l = []
with open('E0.csv') as csvfile:
reader = csv.DictReader(csvfile)
for x in reader:
if x['HomeTeam'] == 'Liverpool' or x['AwayTeam'] == 'Liverpool':
l.append(x)
with open('Liverpool.csv', 'w') as output:
fields = ['Date', 'HomeTeam', 'AwayTeam', 'FTHG', 'FTAG', 'FTR']
writer = csv.DictWriter(output, fieldnames=fields, extrasaction='ignore')
writer.writeheader()
writer.writerows(l)
json formátum kezelése Pythonban¶JavaScript Object Notation
Tárolhatunk benne számokat, sztringeket, listát, szótárat. Sőt, tetszőlegesen egymásba ágyazhatunk szótárakat, listákat, listák listáját, szótárak listáját, szótárak szótárát, listák szótárát. Listák elemeit vesszővel választjuk el, a szótárakat pedig mint a Pythonban key:value módon adjuk meg.
{
"Liverpool" : {
"Players": [
"Steven Gerrard",
"Bill Shankly"
],
"Results" : [
{
"HomeTeam":"Liverpool",
"AwayTeam":"Tottenham",
"HTG":1,
"ATG":1
},
{
"HomeTeam":"West Ham",
"AwayTeam":"Liverpool",
"HTG":2,
"ATG":0
}
],
"Points":1,
"Goals Scored":1,
"Goals Condceded":3
}
}Pythonnal a json-t is kényelmesen lehet kezelni. Egyszerűen beolvassuk a fájlt és kiírjuk a képernyőre. Látjuk, hogy Python szótár keletkezett belőle, tehát hivatkozhatunk a kulcsaira.
import json
with open('Liverpool.json') as data_file:
data = json.load(data_file)
print(data)
print(data['Liverpool']['Players'])
Írjuk ki egy fájlba a meccsek eredményeit! A külalakra is figyelünk, erre való a sort_keys, az indent és a separators. A json.dumps(obj) tetszőleges Python objectet json sztringgé alakít, így ezt egyszerűen kiírjuk a fájlba!
import json
with open('Liverpool.json') as data_file:
data = json.load(data_file)
with open('Liverpool_matches.json', 'w') as f:
f.write(json.dumps(data['Liverpool']['Results'],
sort_keys=True, indent=4, separators=(',', ': ')))
json.dump(JSON_formaju_szoveg, file): kiírás fájlba
json.dumps(objektum): objektum JSON formátumúvá konvertálása
json.load(file): a file-ban lévő JSON formátumú dokumentumot Python objektummá konvertál
json.loads(JSON_formaju_szoveg): JSON formátumú sztringet Python objektummá konvertál
Részletek a Python dokumentációban.
Szeretnénk a Python programunknak kívülről átadni paraméterértékeket!
Elmentünk .py végződéssel egy fájlt. Ezt vagy a rendszer felismeri mint Python scriptet vagy megfelelő paranccsal indítjuk. Első programunkkal kiírjuk a bemeneti paraméterek számát és listáját. Az első elem mindig a script neve. A paramétereket a sys.argv listában tárolja a Python. Ehhez kell az import sys csomag betöltése. Minden argumentum karakterlánc (list of str).
A következő kódot írjuk ki egy fájlba, és futassuk parancssorból a megfelelő paranccsal.
import sys
print('Az argumentumok száma: ', len(sys.argv))
print('Az argumentumok listája:', sys.argv)
! python3 parancssori.py arg1 arg2
A ! jelzi, hogy azt a cellát parancssorba futtassa a notebook.
Az ilyen paramétereket hívjuk pozicionális paramétereknek, hiszen a sys.argv listában elfoglalt helyük alapján azonosítjük őket.
Feladat: emeljünk egy számot adott hatványra! Ha az alap és a kitevő is egész, akkor számoljuk a hatványt egészek hatványaként, különben lebegőpontosként. A két számot parancssori argumentumként adjuk át a programnak.
A következő kódot másoljuk egy fájlba és parancssorból futtassuk!
import sys
def is_intstring(s):
try:
int(s)
return True
except ValueError:
return False
a = []
for i in range(1,3):
if is_intstring(sys.argv[i]):
a.append(int(sys.argv[i]))
else:
a.append(float(sys.argv[i]))
print(a[0] ** a[1])
A futtatások eredményei:
!python3 hatvany.py 4.2 3
!python3 hatvany.py 2 100
Linux alatt, ha a Python fájl első sora
#!/usr/bin/python3
és a fájl futtatható (ha nem, a chmod +x filename parancs azzá teszi), akkor a python3 parancs elhagyható:
!hatvany.py 2 1000