Informatika2-2012/Eloadas08

A MathWikiből
(Változatok közti eltérés)
(Adattípusok)
(Code style PEP 8 alapján)
 
(egy szerkesztő 7 közbeeső változata nincs mutatva)
1. sor: 1. sor:
 +
[http://wiki.math.bme.hu/view/Informatika2-2012 <-- vissza]
 +
 
== Python-ról általában ==
 
== Python-ról általában ==
 
A Python egy olyan általános körben használható magas szintű programozási nyelv, aminek az egyik alap elve az olvasható kód írása egy nagyon tiszta szintaxis használatával. 1991-ben alkotta meg [http://en.wikipedia.org/wiki/Guido_van_Rossum Guido Van Rossum.]
 
A Python egy olyan általános körben használható magas szintű programozási nyelv, aminek az egyik alap elve az olvasható kód írása egy nagyon tiszta szintaxis használatával. 1991-ben alkotta meg [http://en.wikipedia.org/wiki/Guido_van_Rossum Guido Van Rossum.]
33. sor: 35. sor:
 
* 80 karakternél ne legyen hosszabb egy sor
 
* 80 karakternél ne legyen hosszabb egy sor
 
* CamelCase elnevezési konvenciót kövesse az osztályok neve és lower_case_with_underscores a függvények nevei
 
* CamelCase elnevezési konvenciót kövesse az osztályok neve és lower_case_with_underscores a függvények nevei
 +
 +
[http://google-styleguide.googlecode.com/svn/trunk/pyguide.html Google python code style]
  
 
=== Docstring ===
 
=== Docstring ===
45. sor: 49. sor:
  
 
Első sort nagybetűvel kezdjük és pontal zárjuk. Egy összefoglaló mondat legyen. Majd egy üres sort hagyva részletesen leírhatunk minden funkciót amit az osztály vagy függvény tartalmaz.
 
Első sort nagybetűvel kezdjük és pontal zárjuk. Egy összefoglaló mondat legyen. Majd egy üres sort hagyva részletesen leírhatunk minden funkciót amit az osztály vagy függvény tartalmaz.
 +
 +
==== Hasznos linkek ====
 +
[http://www.python.org/dev/peps/pep-0257/ hogyan érdemes]
 +
 +
[http://docs.python.org/library/doctest.html unittest-elés docstring segítségével]
 +
 +
[http://packages.python.org/an_example_pypi_project/sphinx.html Sphinx]
  
 
== Adattípusok ==
 
== Adattípusok ==
380. sor: 391. sor:
 
</python>
 
</python>
 
* <python>reversed(list)</python> - segítségével a paraméterként kapott felsorolás elemeit megfordító objektummá alakítja
 
* <python>reversed(list)</python> - segítségével a paraméterként kapott felsorolás elemeit megfordító objektummá alakítja
* <python>sorted(sorozat)</python> - segítségével a paraméterként kapott felsorolás elemeit rendezett listában visszaadja
 
* <python>len(sorozat)</python> - segítségével a sorozat hosszát kaphatjuk meg
 
 
== függvények definiálása és használata ==
 
 
Amikor függvényeket definiálunk, akkor igazán nem fut le semmilyen létrehozott kod, csak egy ellenőrzés, amivel kizárja az interpreter a szintaktikai hibákat (olyan hiba ami a kod szövegéből ered).
 
 
A függvényben megírt kód csak a függvény hívásakor fut le és a változói akkor lesznek kiértékelve.
 
 
 
<python>
 
<python>
def fvdef():
+
>>> l
  pass # a pass egy olyan parancs ami nem csinal semmit
+
[8, 7, 6, 5]
  return x**2-1
+
>>> reversed(l)
</python>
+
<listreverseiterator object at 0xb722628c>
 
+
>>> l
Itt meg nem futott le semmi csak a fuggvény hívásakor.
+
[8, 7, 6, 5]
 
+
<python>
+
fvdef()
+
 
</python>
 
</python>
 
+
* <python>sorted(sorozat)</python> - segítségével a paraméterként kapott felsorolás elemeit rendezett listában visszaadja
Maga a függvényben definiált kód csak a meghívásakor fut le.
+
 
+
Meghívni a függvényt a függvény nevével lehet, úgy hogy utána a zárójelben megadjuk a paraméterként szánt értékeket. (Ha nem kell megadni paramétert akkor csak üres zárójelet használunk... "()")
+
 
+
=== alapértelmezett paraméter érték ===
+
Ha csak simán definiálunk egy függvényt amiket paraméterekkel lehet csak használni, akkor azok a paraméterek kötelezöek
+
 
+
 
<python>
 
<python>
def a_d_test(fv, vert):
+
>>> l = [8,7,6,5]
  return fv * vert
+
>>> sorted(l)
 
+
[5, 6, 7, 8]
a_d_test(5)
+
>>> l
 
+
[8, 7, 6, 5]
Traceback (most recent call last):
+
  File "<stdin>", line 1, in <module>
+
TypeError: a_d_test() takes exactly 2 arguments (1 given)
+
 
</python>
 
</python>
 
+
* <python>len(sorozat)</python> - segítségével a sorozat hosszát kaphatjuk meg
Ezért lehetséges alapértelmezett értékeket beállítani a definiálás során, ez az érték egyszer értékelődik ki és utána mindig az lesz az alapértelmezett.
+
 
+
 
+
 
<python>
 
<python>
def a_d_test(fv, vert = 1):
+
>>> len(l)
  return fv * vert
+
4
 
+
>>> len(s)
a_d_test(5)
+
0
 +
>>> len(s2)
 
5
 
5
</python>
 
  
Fontos hogy azok a paraméterek amiket alapértelmezett értékkel akarunk ellátni a paraméterezésben hátulról kell beilleszteni.
 
<python>
 
SyntaxError: non-default argument follows default argument
 
 
</python>
 
</python>
 
=== kulcsszavas paraméter érték ===
 
Lehetséges a paraméterek neveivel is átadni a kívánt elemeket:
 
<python>
 
a_d_test(vert=2, fv=2)
 
</python>
 
 
Itt is fontos, hogy ha valamit kulcsszóval akarunk átadni, akkor azt a függvény hívás paraméterlistájának végétől kell feltölteni.
 
 
=== tetszőleges paraméter kezelése ===
 
Lehetőség van tetszőleges paramétert kezelni a '''*<nev>''' paraméter elkérésével
 
<python>
 
def as_many(*args):
 
  for i in args:
 
    print i,
 
 
as_many('trali', 'fari')
 
trali fari
 
</python>
 
 
=== tetszőleges nevesített paraméterek ===
 
<python>
 
def as_many_as(**args):
 
  for k,v in args.iteritems():
 
    print k, "erteke: ", v
 
 
as_many_as(elso='trali', masodik='fari')
 
elso erteke:  trali
 
masodik erteke:  fari
 
</python>
 
 
Ahogy láthatjuk itt nevet adhatunk az értéknek és nem csak a pozíciója határozza meg hogy mihez is lehet kötni az elemet.
 
Fontos hogy mivel nem számíthatunk hogy megkapjuk-e azt a paramétert a függvény hívásakor ezért mindig ellenőrizzük annak meglétét.
 
 
== Változók érvényességi köre ==
 
 
A nevek egy változóra hivatkoznak. Egy blokk olyan programrész, ami egy egységként hajtódik végre. A mi esetünkben egy függvény törzse blokk (de egy parancs is blokként értelmezett).
 
 
Egy blokk futtatása úgynevezett "futtatási keretben" történik (administrációs és futtatási okokból).
 
 
A scope a láthatóságát jelenti az adot változónak.
 
 
* ha változót deklarálunk egy blokkon belül akkor annak láthatósága arra a blokra korlátozódik
 
* ha a blokkon belül újabb blokkot hozunk létre, akkor ott is értelmezett lesz a változó, kivéve ha a belső blokkon belül azt nem definiáljuk felül, azaz nem adunk értéket neki
 
* továbbá ha a külső blokkbeli változót szeretnénk használni, majd annak értéket adni a belső blokkban, az hibát fog okozni, mert ugyan bárhol deklarálhatunk változót, de blokkon belül a deklaráció előtt nem lehet használni azt a változót.
 
 
<python>
 
def fv():
 
  return a
 
 
a=7
 
fv()
 
</python>       
 
 
Látható, hogy a külső blokkban deklarált "a" változó látható a függvényen belül is.
 
 
<python>
 
a=7
 
def sz2():
 
  a=2
 
  return a
 
       
 
print a
 
print sz2()
 
print a
 
</python>   
 
 
Latható, hogy ha a belső blokkon belül deklarálunk már létező névvel új változót, akkor az csak a belső blokkon belül lesz értelmezett.
 
 
<python>
 
a=7
 
def sz3():
 
  b=a
 
  a=6
 
  return b
 
 
Traceback (click to the left of this block for traceback)
 
...
 
UnboundLocalError: local variable 'a' referenced before assignment
 
 
</python>
 
 
Látszik, hogy "a" ugyan létezik, de mivel a belső blokkon belül újra deklaráljuk, igy a deklaráció előtt nem használhatjuk azt.
 
 
A hiba egyszerű de nem szép megoldására a python a '''global''' kulcsszót adja a kezünkbe.
 
<python>
 
a=7
 
def sz3():
 
  global a
 
  b=a
 
  a=6
 
  return b
 
</python>
 
 
Programtervezési irányelveket követve az előző hibát más eszközökkel kell megoldani.
 
 
== Program struktúra ==
 
A python lehetőséget ad bonyolult program szétdarabolására hogy az átláthatóbb legyen a fejlesztők számára
 
A '''csomagok és a modulok''' kialakításával érhetjük el a darabolást.
 
=== csomag ===
 
Kiszervezhető és akár önmagukban is futtatható nagyobb független kódrészletekre használatos. Egy adott területhez tartozó feladatokat látja el.
 
Általában több modul és alcsomagokat tartalmaz.
 
 
Pl: numpy - "NumPy is the fundamental package for scientific computing with Python."
 
 
Mitől lesz valami csomag? Csomaggá az a könyvtár változhat ami tartalmazza a '''__init__.py''' fájlt. Ez a fájl jelzi az fordító számára, hogy egy csomagról van szó. A __init__.py üresen is elég, de vannak extra változók amiket lehet használni a csomag könnyebb használata érdekében (__all__, __path__, ...)
 
 
=== modul ===
 
Kisebb egybefüggő programrészek egysége. Maga a python programot tartalmazó file egy modult képez.
 
 
A modul neve a file nevével egyezik amiben van a kód. Így pl.: a protak.py programfájlban lévő modulra a protak névvel tudunk hivatkozni. A modul nevét a programon belül a '''__name__''' változóval érjük el. Fontos, hogy ha a modult mint program indítjuk akkor a __name__ értéke __main__ lesz! Ezt fel lehet használni pl.:
 
 
'''tortin.py''' fájl tartalma:
 
<python>
 
  def mainp():
 
    print "This is the main"
 
 
  def elp():
 
    print 'This is not the main'
 
 
  if __name__ == '__main__':
 
    mainp()
 
  else:
 
    elp()
 
</python>
 
 
Majd hivjuk meg konzolbol a
 
 
<code>
 
python tortin.py
 
</code>
 
 
illetve interpreterből...
 
 
<code>
 
import tortin
 
</code>
 
 
(A modul elnevezést szokás használni még azokra a csomagokra is amiket különálló általános problémákat lehet kezelni pl. numpy és azokra amik kiterjesztési csomagok azaz más nyelvhez (pl.: C) való kapcsolódást valósít meg.)
 
 
=== csomagok és modulok felhasználása (import) ===
 
A programrészeket felhasználhatjuk a programon belül akárhol, ha azt jelezzük a fordítónak.
 
 
A python-on belül ezt az '''import''' vagy a '''from és az import''' kulcsszavakkal tehetjük meg a következő módon.
 
 
<python>
 
  import sys
 
  from sys import stdin
 
  from sys import maxint as mi
 
  from mymodule import *
 
</python>
 
 
* az '''import sys''' paranccsal az összes sys modul alatt elérhető függvényhez és változóhoz hozzáférünk. pl.: sys.maxint vagy sys.ps1
 
* az '''from sys import stdin''' paranccsal a programon használhatjuk a sys modulban definiált stdin változót a saját nevén, azaz a fájlon belül elérhető a stdin változó.
 
* a '''from sys import maxint as mi''' nagyon hasonló az előzőhöz csak itt meg megadtuk azt is hogy a mi modulunkban mi a maxint változót a '''mi''' néven akarjuk elérni.
 
* végül a '''from mymodule import *''' sorral azt adtuk meg, hogy mymodule minden eleme (kivéve a "_" karakterrel kezdődőek) elérhetőek legyenek. A * használata csomag import esetén kerülendő, modul esetén is megfelelő figyelemmel!
 
 
==== relatív import útvonalak ====
 
Bonyolultabb csomagokban ahol több alcsomag és sok-sok modul található az egymáshoz való hivatkozásokhoz használhatunk relatív útvonalakat.
 
 
<python>
 
  from . import torti
 
  from .. import kerek
 
  from ..vaz import orr
 
</python>
 
 
=== modul és csomag nevek feloldása ===
 
Az fordító először a
 
# '''beépített modulok''' között keres, ha ott nem találja, akkor
 
# '''sys.path''' - ban lévő útvonalakat próbálja végig ami a következőképpen épül fel:
 
## az indítás könyvtárába
 
## PYTHONPATH
 
 
=== elérhető elemek ===
 
Az elérhető elemeket egy adott modulon belül a '''dir()''' függvénnyel listázhatjuk ki
 
  
 
== Megjegyzések ==
 
== Megjegyzések ==
 
* [http://info.ilab.sztaki.hu/~kisstom/info2_2011/1het/ea/1het.pdf 2011-es év előadás anyaga, érdemes átnézni, hátha letisztáz pár kérdést]
 
* [http://info.ilab.sztaki.hu/~kisstom/info2_2011/1het/ea/1het.pdf 2011-es év előadás anyaga, érdemes átnézni, hátha letisztáz pár kérdést]

A lap jelenlegi, 2012. augusztus 6., 21:36-kori változata

<-- vissza

Tartalomjegyzék

Python-ról általában

A Python egy olyan általános körben használható magas szintű programozási nyelv, aminek az egyik alap elve az olvasható kód írása egy nagyon tiszta szintaxis használatával. 1991-ben alkotta meg Guido Van Rossum.

További jellemzők

  • objektum orientált (imperatív, procedurális), funkcionális
  • sok beépített modul a fejlesztés megkönnyítésére
  • dinamikus típus kezelés
  • automatikus memóriakezelés
  • többféle megvalósítás (CPython, Jython, IronPython, PyPy, Python for S60)
  • open-source a főbb platformokra

Python kód futtatása

A kód futtatható interpreter konzolon belül és külső fájlban tárolva. A tavalyi előadást mint ismétlés ajánlom átnézni. (Tananyag része!)

Python szintaktika és az értelmezése

  • változók definiálása és egyben deklarálása az = operátorral típus definiálása nélkül
  • minden változó egy objektumként jelenik meg a háttérben aminek a típusát a type(obj) függvénnyel kérhetjük el.
  • azonos kódblokkokat azonos behúzással jelöljük
  • kódblokk kezdetét a : jelzi
  • megjegyzést a # karakterrel tudsz beírni, ami azt jelenti, hogy a sorban utána lévő karaktereket már nem veszi figyelembe a fordító (sok helyen láthatsz olyat, hogy hivatkozás nélküli string-kel csinálják)
  • lista másolása a MyLista[:] kifelyezéssel tehetjük meg. Fontos mivel több referencia használatával a lista módosításával esetleg olyan eredményt kaphatunk amire nem számítunk.
  • egyszerre több elem inicializálása a=b=c=1
  • a sorozat elemei kiszedhetőek a, b = [4, 5]. Fontos hogy az összes elemre kell változót írnunk!
  • az előbbi struktúrát átültethetjük több változó több változóval való értékadására
  • használható a 5 <= summa < 10 kifejezés is, ami olyan mintha kiírnánk a summa >= 5 and summa < 10

Code style PEP 8 alapján

  • használj mindig 4 space-t minden egyes szinthez
  • a nagyobb kódrészeket tagold üres sorokkal (függvény, osztály, nagyobb kód blokk)
  • használj space-t a vesző után és az operátorok mellett
  • használj docstring-et és ahol lehet a megjegyzés a saját sorára vonatkozzon
  • ahol lehet használj ASCII karakterkódolást
  • 80 karakternél ne legyen hosszabb egy sor
  • CamelCase elnevezési konvenciót kövesse az osztályok neve és lower_case_with_underscores a függvények nevei

Google python code style

Docstring

Ahogy már említettük, a hivatkozás nélküli string elemet szokás használni megjegyzések írására és dokumentálásra.

"""This is a class of example.

TODO: needs implementation. """

Első sort nagybetűvel kezdjük és pontal zárjuk. Egy összefoglaló mondat legyen. Majd egy üres sort hagyva részletesen leírhatunk minden funkciót amit az osztály vagy függvény tartalmaz.

Hasznos linkek

hogyan érdemes

unittest-elés docstring segítségével

Sphinx

Adattípusok

  • None - a semmi programbeli megvalósulása
  • numerikus
    • egész
    • lebegőpontos
    • (complex)
    • long
    • boolean
  • sorozatok - elemeik egész számmal indexelhetőek
    • módosíthatatlanok
      • string
      • tuple
>>> t = ()
>>> t
()
>>> t = tuple()
>>> t
()
>>> t = (1,2,'')
>>> t
(1, 2, '')
>>> t = 3,4,5,''
>>> t
(3, 4, 5, '')
>>> t[2]
5
>>> t.count(5)
1
>>> t.index(5)
2
    • módosíthatóak
      • lista
>>> l = []
>>> l
[]
>>> l = list()
>>> l
[]
>>> l = [1, "p", ['k'], 2.5]
>>> l
[1, 'p', ['k'], 2.5]
>>> l += [1]
>>> l
[1, 'p', ['k'], 2.5, 1]
>>> l.pop()
1
>>> l
[1, 'p', ['k'], 2.5]
>>> l.reverse()
>>> l
[2.5, ['k'], 'p', 1]
>>> l.count(1)
1
>>> l.insert(1,1)
>>> l.count(1)
2
>>> l
[2.5, 1, ['k'], 'p', 1]
>>> l.remove(1)
>>> l
[2.5, ['k'], 'p', 1]
  • halmazok
    • halmaz (set)
>>> s = set([5,6,7,8,6])
>>> s
set([8, 5, 6, 7])
>>> s2 = set()
>>> s2
set([])
>>> s2 = s.copy()
>>> s2
set([8, 5, 6, 7])
>>> s2.add(6)
>>> s2.add(11)
>>> s2
set([8, 11, 5, 6, 7])
>>> s2.difference(s)
set([11])
>>> s2.discard(11)
>>> s2.difference(s)
set([])
>>> s2.intersection(s)
set([8, 5, 6, 7])
>>> s2.update([5,4,3])
>>> s2
set([3, 4, 5, 6, 7, 8])
>>> s2.discard(2)
>>> s2
set([3, 4, 5, 6, 7, 8])
>>> s2.remove(3)
>>> s2
set([4, 5, 6, 7, 8])
>>> s2.remove(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 3
>>> s
set([8, 5, 6, 7])
>>> s.union(set([56,5]))
set([56, 5, 6, 7, 8])
>>> s
set([8, 5, 6, 7])
>>> s2
set([4, 5, 6, 7, 8])
>>> s.clear()
>>> s
set([])
  • térképezés
    • szótár (dict)
>>> d = dict()
>>> d
{}
>>> d = {}
>>> d
{}
>>> d = {'fn':'Marci', 'ln':'Pala', 2:89}
>>> d
{'ln': 'Pala', 2: 89, 'fn': 'Marci'}
>>> d[2]
89
>>> d['ln']
'Pala'
>>> d2 = d.copy()
>>> d2
{'ln': 'Pala', 2: 89, 'fn': 'Marci'}
>>> d2[2] = 8
>>> d2
{'ln': 'Pala', 2: 8, 'fn': 'Marci'}
>>> d
{'ln': 'Pala', 2: 89, 'fn': 'Marci'}
>>> d.update([("t",3),('b',6)])
>>> d
{'ln': 'Pala', 2: 89, 'b': 6, 't': 3, 'fn': 'Marci'}
>>> d2
{'ln': 'Pala', 2: 8, 'fn': 'Marci'}
>>> d.values()
['Pala', 89, 6, 3, 'Marci']
>>> d.pop('b')
6
>>> d
{'ln': 'Pala', 2: 89, 't': 3, 'fn': 'Marci'}
>>> d.keys()
['ln', 2, 't', 'fn']
>>> d.items()
[('ln', 'Pala'), (2, 89), ('t', 3), ('fn', 'Marci')]
>>> d.iteritems()
<dictionary-itemiterator object at 0x00B73C90>
>>> d.get('teki')
>>> d.get('teki', t)
(3, 4, 5, '')
>>> d
{'ln': 'Pala', 2: 89, 't': 3, 'fn': 'Marci'}
>>> d['teki']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'teki'
>>> len(d)
4
>>> d.clear()
>>> d
{}
>>> len(d)
0
>>> d2
{'ln': 'Pala', 2: 8, 'fn': 'Marci'}

Fontos tudni, hogy a numerikus és a módosíthatatlan sorozatok úgymond "változtathatatlanok" ami annyit tesz, hogy ha egy elemre több hivatkozásunk van, akkor ha az egyiket megváltoztatom akkor az új értékkel keletkezik egy új elem a memóriában és a hivatkozás már erre fog mutatni. (Ez a felhasználó számára láthatatlan!)

Ezek az alapvetően használt elemek, ezen felül van meg sok egyéb amelyek közül a legfontosabb az osztályok amiket később fogunk venni. Ha többet akartok tudni a python adatmodelljéről akkor itt találtok leírást róla.

változók névadásánál a következő szabályok vonatkoznak:

  • a név betüvel vagy aláhúzással kezdődhet: [_a-zA-Z] - ez egy reguláris kifejezés ami megegyezik a leírt feltétellel
  • a név további karakterei az előbbin felül lehet szám is: [_a-zA-Z0-9]
  • elméletileg bármilyen hosszú lehet a név
  • név nem lehet foglalt szó
  • nagybetü kisbetü érzékeny, tehát a val1 név nem azonos a Val1 névvel

Másképp leírva:

identifier ::= (letter|"_") (letter | digit | "_")*

letter  ::= lowercase | uppercase

lowercase  ::= "a"..."z"

uppercase  ::= "A"..."Z"

digit  ::= "0"..."9"

A foglalt szavak:

and del from not while as elif global or with assert else if pass yield break except import print class exec in raise continue finally is return def for lambda try

Operátorok

Operátorok precedenciája

Az operátorok között, mint a matematikában itt is, van precedenciai sorrend:

Operator Description
lambda Lambda expression
if – else Conditional expression
or Boolean OR
and Boolean AND
not x Boolean NOT
in, not in, is, is not, <, <=, >, >=, <>, !=, == Comparisons, identity test, including membership test
|
Bitwise OR
^ Bitwise XOR
& Bitwise AND
<<, >> Shifts
+, -
Addition and subtraction
*, //, /, % Multiplication, division, remainder
+x, -x, ~x
Positive, negative, bitwise not
** Exponentiation
x[index], x[index:index], x(arguments...), x.attribute Subscription, slicing, call, attribute reference
(expressions...), [expressions...], {key:datum...}, `expressions...` Binding or tuple display, list display, dictionary display, string conversion

A sage, python a kifejezéseket balról jobbra értékeli ki, kivéve az értékadásnál, amikor előbb a jobb oldalt értékeli ki, majd a ball oldalt.

pl.:

logikai kifejezés elemeit ha mar felesleges nem értékeli ki

Vezérlési elemek

A vezérlési elemeket az előző félévben a SAGE-el kapcsolatban már átnéztük, ezeket kell tudni. Info1 kapcsolódó diái

Összefoglalva:

Elágazás

  • if (elif, else)

Ciklusok

  • while (else)
  • for (else)
  • break, continue

Hasznos segítőeszközök

Ciklusok során a következő nyelvi elemeket találhatjuk hasznosnak:

  • range(x,z,y), xrange(x,y,z)
    - ezekkel számlistákat tudunk előállítani. első paraméter a mettől, a második a meddig és a harmadik a lépésköz. Csak a meddig paraméter a kötelező, a kezdet alapból 0 és a lépésköz pedig 1. Nagy listák esetén az xrange optimálisabb kódot eredményez
  •  enumerate(x)
    - ennek segítségével az elemekkel megkapjuk a listában betöltött helyüket is
>>> for i,v in enumerate(l):
...   print 'index:',i,'and value:',v
...
index: 0 and value: 2.5
index: 1 and value: ['k']
index: 2 and value: p
index: 3 and value: 1
  • d.iteritems()
    - segítségével a szótár egy elemének kulcsával és értékével tér vissza
>>> for k, v in d2.iteritems():
...   print 'key:',k,'and value:',v
...
key: ln and value: Pala
key: 2 and value: 8
key: fn and value: Marci
  • zip(list, ...)
    - segítségével a paraméterként kapott sorozatok elemeit csoportosítja elhelyezkedésük szerint.
>>> import copy
>>> l2 = copy(l)
>>> l2 = copy.copy(l)
>>> l2
[2.5, ['k'], 'p', 1]
>>> l
[2.5, ['k'], 'p', 1]
>>> l2[1] = 0
>>> l
[2.5, ['k'], 'p', 1]
>>> l2
[2.5, 0, 'p', 1]
>>> zip(l, l2)
[(2.5, 2.5), (['k'], 0), ('p', 'p'), (1, 1)]
  • reversed(list)
    - segítségével a paraméterként kapott felsorolás elemeit megfordító objektummá alakítja
>>> l
[8, 7, 6, 5]
>>> reversed(l)
<listreverseiterator object at 0xb722628c>
>>> l
[8, 7, 6, 5]
  • sorted(sorozat)
    - segítségével a paraméterként kapott felsorolás elemeit rendezett listában visszaadja
>>> l = [8,7,6,5]
>>> sorted(l)
[5, 6, 7, 8]
>>> l
[8, 7, 6, 5]
  • len(sorozat)
    - segítségével a sorozat hosszát kaphatjuk meg
>>> len(l)
4
>>> len(s)
0
>>> len(s2)
5

Megjegyzések

Személyes eszközök