A Python hasznos eszközei

A mai cikkben folytatjuk a Python eszközrendszerének áttekintését. Mint azt látni fogjuk, számtalan hasznos eszközt tartalmaz a nyelv beépítve, melyek nagyban megkönnyítik és gyorsítják a kódolás folyamatát. Ezeket az eszközöket sok más nyelvvel ellentétben natívan tartalmazza, tehát nem szükséges külső függvénykönyvtárak csatolása azok használatához.

List comprehension

Az egyik talán legérdekesebb eszköze a nyelvnek az úgynevezett „list comprehension” („lista-felfogás”) módszer, amellyel kompakt módon tudunk az előző cikkből megismert listákat létrehozni. Lényege, hogy a lista elemeit nem direkt módon adjuk meg, hanem egy speciális iterációval. Abban még nem is lenne semmi meglepő, hogy ilyen módon töltjük fel a listát, evidens, hogy mondjuk, ha fel akarunk tölteni egy listát 1-től 100-ig számokkal, akkor azt iterációval fogjuk megvalósítani. Tehát felmerülhet a kérdés, mi a különleges a list comprehension módszerben. Nos az, hogy ehhez nem szükséges egy komplett, klasszikus iterációt megírnunk, hanem elintézhetjük ezt egy egyszerű, egyetlen soros összetett utasításban. Az érthetőség kedvéért mutatnék egy példát, aztán jön a magyarázat. Az összehasonlíthatóság kedvéért pedig nézzük a fenti példát mindkét módszerrel:

Klasszikus megoldás

lista = [] # üres lista deklarációja
for i in xrange(1, 101): # iteráció 1-től 100-ig
lista.append(i) # a lista bővítése a ciklusváltozó aktuális értékével

List comprehension módszer:

lista = [i for i in xrange(1, 101)] # a fentiek mind egy sorban

Mint láthatjuk, kódunk így tömörebb lett, persze, ki-ki maga döntse el, mennyire átlátható és kényelmes ez a módszer, az biztos, hogy sokkal gyorsabb lekódolni. Most nézzük hogyan is épül fel az utasítás:

<lista változó> = [<kifejezés> for <ciklusváltozó> in <tartomány> if <feltétel>]

A értelemszerűen egy újonnan elkészülő listára fog hivatkozni. Azt, hogy ez egy lista lesz, amint azt már láttuk, szögletes zárójelekkel jelöljük ([…]). És itt jön ténylegesen a list comprehension módszer megoldása. A értékével lesz bővítve a listánk, mely értékeket a for iteráció sorunk határozunk meg. Ez lehet akár konstans érték is, vagy függhet a értékétől is. Fontos megjegyezni, hogy nem véletlenül használjuk itt a „kifejezés” szót, ugyanis itt valóban egy kifejezés kiértékelése történik meg, például a függvényekkel vagy matematikai műveletekkel történő manipulációjával. A for iterációt már megismerhettük az előző cikkből. Az if záradék opcionális, segítségével megadhatunk egy feltételt, ily módon szűrve a számunkra szükségtelen elemeket. Hogy nagyjából világos legyen az eszköz használata, nézzünk egy példát! Építsünk fel egy olyan listát, amelyben az 1 – 100 intervallum páros számainak négyzetei szerepelnek:

Klasszikus megoldás

paros_negyzet = []
for i in xrange(1, 101):
if i % 2 == 0:
paros_negyzet.append(i**2)

List comprehension

paros_negyzet = [i**2 for i in xrange(1, 101) if i % 2 == 0]

Tuple, dictionary, set

Az előző cikkből kimaradt még egy, a listákhoz hasonló eszköz bemutatása: ezek a tuple-ök. A listáktól annyiban különben, hogy az ezekben tárolt minden érték immutable, azaz inicializálás után nem módosítható. Minden egyéb tulajdonságban egyeznek a listákkal, ugyanúgy lehet elérni az elemeiket, ugyanúgy járhatóak be, elemeinek típusa itt is eltérő lehet, de a módosításokat megvalósító utasítások itt nem használhatóak. A listákkal együtt használva őket tulajdonképpen „struktúra-tömböket” hozhatunk létre, melyek hivatkozása úgy történik, mintha egy kétdimenziós tömb elemeit akarnánk elérni. A mellékelt példaprogramban látható lesz majd a használata.

A dictionary, azaz szótár adatszerkezet a PHP nyelv asszociatív tömbjeihez hasonló szerkezet, benne kulcs – érték párok rögzítése lehetséges. Inicializációja egy kapcsos zárójel-párral történik, majd egyenként tudjuk az elemeket hozzáadni oly módon, mintha egy tömb elemeire hivatkoznánk, annyi különbséggel, hogy ez esetben az index nem csak szám lehet. A kulcsok és az elemek is bejárhatóak for iterációval, előbbihez a keys() metódus áll rendelkezésünkre, utóbbihoz az items() és az iteritems(). Utóbbiak tuple-öket állítanak elő, melyekben a kulcsok és az értékek is szerepelnek; különbség a kettő közt ugyanaz, mint a range és az xrange függvény esetén.

A set (halmaz) adatszerkezet a klasszikus matematikai halmazfogalom megjelenése a Pythonban. Segítségével egyetlen lépésben tudjuk egy listában fellépő ismétlődéseket eltávolítani (mivel a halmazokban nem lehet két azonos elem). Az unió- és metszetképzés, valamint a kivonás művelete is megvalósítható, ezeket rendre a union(), intersection() és difference() függvényekkel tehetjük meg.

Globális változók és konstansok

Globális változónak – mint minden nyelv – a Python azokat a változókat tekinti, melyek láthatósága a teljes programra kiterjed. Ezeket a változókat a program elején kell deklarálni, minden függvényen és osztályon kívül. Az ilyen módon deklarált változók pedig a programon belül bárhol elérhetőek és módosíthatók. Azonban, ha egy függvényben hozzá akarunk férni egy globális változó tartalmához, akkor nem elég csupán a nevével hivatkozni rá, mert ekkor egy a globális változónk nevével megegyező nevű lokális változó jön létre. Így egyrészt, ha a globális változót szeretnénk módosítani, akkor nem ez fog történni, másrészt elveszítjük a globális változó láthatóságát. A globális változó eléréséhez a függvényben ki kell adnunk a global utasítást, ezután ha hivatkozunk rá a függvényben, akkor már a globális változót fogjuk elérni.

A nyelv egyik hiányossága, hogy nem létezik benne valódi konstans típus, megállapodás szerint a csupa nagybetűkkel írt változókat tekintjük „konstansnak”. Így csak a programozó figyelmességén múlik, hogy az így deklarált változók tartalma érintetlen maradjon a script futásának teljes ideje alatt.

Túlcsordulás

Érdekességképp érdemes megemlíteni, hogy a Pythont nem különösebben izgatja a túlcsordulás fogalma. A legtöbb nyelvből megszokhattuk, hogy amennyiben egy változó típusának maximális értékével rendelkezik, azon bármilyen növelő műveletet végrehajtva komoly problémákkal találhatjuk magunkat szemben. A példaprogramban látható lesz majd, hogy a sys.maxint konstans értékét eltárolva egy változóban, majd azt egyel növelve, a művelet sikeresen végrehajtódik: az interpreter automatikusan konvertálja a változó típusát az egyel nagyobb nagyságrendet képviselő long int típusra. Persze ebből kifolyólag az sem akadály neki, hogy igazán nagyméretű számokat eredményező műveleteket hajtsunk végre.

Mára ennyit szerettem volna, a következő cikkben előreláthatólag a fájlkezelésről lesz szó, meg még addig eldől. A cikk alján most is találtok egy példaprogramot, érdemes megnézni azt is, mert sok olyan információ van benne, amit külön a cikkben nem akartam leírni.

#!/usr/bin/env python
# coding: utf-8

import sys

globalis_valt = 5

def list_comp():
    print " ## 1. példa: listák feltöltése" 
    
    # lista feltöltése klasszikus módszerrel
    paros_negyzet_v1 = []
    for i in xrange(1, 101):
        if i % 2 == 0:
            paros_negyzet_v1.append(i**2)
            
    # lista feltöltése list comprehension módszerrel
    paros_negyzet_v2 = [i**2 for i in xrange(1, 101) if i % 2 == 0]
    
    print "Klasszikus módszer: {0}".format(paros_negyzet_v1)
    print "List comprehension: {0}".format(paros_negyzet_v2)
    
def adatszerkezetek():
    print "\n ## 2. példa: tuple, dictionary és set adatszerkezetek"
    print " -- Tuple --"
    
    # Tuple létrehozása és használata
    tuple_1 = ('String', 'k', 5, 9.3)
    for i in tuple_1:
        print i
    
    # Tuple, melynek elemei listák 
    tuple_2 = ([1, 2, 3], ['a', 'b'])
    
    # Lista, melynek elemei tuple-ök
    list_tuple = [ (1, 2, 3), ('a', 'b')]
    
    print "A tuple-ben levő első lista második eleme: {0}".format(tuple_2[0][1])
    print "A listában levő első tuple második eleme: {0}".format(list_tuple[0][1])
    
    # párhuzamos értékadás tuple segítségével:
    (x, y) = (100, 200)
    print "x értéke {0}; y értéke {1}".format(x, y)
    
    print "\n -- Dictionary --"
    # deklarációja az alábbi két módon lehetséges
    d1 = {}
    d2 = dict()
    
    d1['a'] = 'Alfa'
    d1['b'] = 'Beta'
    
    d2['elso'] = 'Első elem'
    d2['masodik'] = 'Második elem'
    d2['harmadik'] = 'Harmadik elem'
    
    print 'd1 szótár elemei'
    # így tuple-ök jönnek létre, hivatkozás a kulcsra és az értékre mint a tuple-öknél
    for i in d1.iteritems():
        print i
        
    # így pedig egyedi változókkal tudunk hivatkozni külön a kulcsra és külön az értékre
    for key, val in d1.iteritems():
        print '{0} -> {1}'.format(key, val)
        
    print 'd2 szótár kulcsai'
    for key in d2.keys():
        print key
        
    print '\n -- Set --'
    # ha van egy listánk, melyben vannak ismétlődések, akkor a set-tel halmazzá alakítva tudjuk azokat kiszűrni
    li_halmaz = [1, 5, 2, 4, 1, 4, 4, 2, 7, 5]
    halmaz = set(li_halmaz)
    
    #halmaz bővítése:
    halmaz.add(10)
    print 'Bővített halmaz: {0}'.format(halmaz)
    
    print 'Halmazműveletek'
    halmaz2 = set([3, 4, 7, 1, 2, 2, 9])
    
    print 'Unió: {0}'.format(halmaz.union(halmaz2))
    print 'Metszet: {0}'.format(halmaz.intersection(halmaz2))
    print 'Különbség: {0}'.format(halmaz.difference(halmaz2))
    
def glob_1():
    print '\n ## 3. példa: globális változók'
    
    # így nem a globális változót érjük el, hanem a függvény által létrehozott lokálisat
    globalis_valt = 10
    
    return globalis_valt

def glob_2():
    # így már a globális változó értékét módosítjuk
    global globalis_valt
    globalis_valt = 10
    
    return globalis_valt

def tulcsord():
    print '\n ## 4. példa: "túlcsordulás"'
    
    # lekérjük a legnagyobb int értéket a sys.maxint konstansból
    a = sys.maxint
    
    # majd kiírjuk az értékét, és a tőle egyel nagyobbat
    print 'maxint: {0}'.format(a)
    a += 1
    print 'maxint + 1: {0}'.format(a)
    
    # a type függvénnyel vizsgálva látható, hogy a változó típusa ekkor már long int
    print type(a)
    
    # ugyanakkor tetszőlegesen nagy egész számok kezelése sem okoz gondot
    print '2^4096 értéke: {0}'.format(2**4096)
    
def main():
    global globalis_valt
    list_comp()
    adatszerkezetek()
    print "Függvény által visszaadott érték: {0} < - > Globális változó értéke: {1}".format(glob_1(), globalis_valt)
    print "Függvény által visszaadott érték: {0} < - > Globális változó értéke: {1}".format(glob_2(), globalis_valt)
    tulcsord()

if __name__ == "__main__":
    main()

Komment írásához jelentkezz be
Bejelentkezés