# -*- coding: iso-8859-2 -*-

# python osszefoglalo: http://docs.python.org/tutorial/

"""
Ez egy hosszú komment,
olyan, mintha itt
sem lenne.
"""

# ez is olyan, csak rövidebb

### Method call:

"abcsd".upper()  --> 'ABC'

".".join("abc")  --> 'a.b.c'

### String interpolation:

def ip(string):
    return "Jobb mint a %s interpoláció" % string.capitalize()

ip("lagrange")  --> 'Jobb mint a Lagrange interpoláció'

Az interpolálandókat egy szótárban is meg lehet adni:

def ip(milyenebb,ki,mennyivel):
    return "%(mennyi)i-el %(mi)s mint a %(ki)s interpoláció" % {'mennyi': mennyivel, 'mi': milyenebb, 'ki': ki.capitalize()}

ip("jobb", "lagrange",4)


### Control structures



if amount > 10:
	print "Túl sok"
elif amount > 5:
	print "OK"
else:
	print "Nem elég"


count = 0
while count < 5:
	print "Még számolunk! (%d)" % count
	count+=1
else: print "Már nem." #ez csak akkor nem torténik meg, ha break hatására lett vége a ciklusnak


for i in range(3,5):
 	print i

### Lists


a = [1, 'két', 3.4, 4]

a[2] -> 3.4
a[1] -> "két"

# [-n]: hátulról az n.
a[-1] -> 4

# a[n:m]: [a[n],..,a[m-1]] (ha n,m nemnegatív)

a[1:3] -> ["két", 3.4]

a[42] -> IndexError: list index out of range

def f(x): return x*x

map(f,range(5,10)) -> [25, 36, 49, 64, 81]

# vagy

[x*x for x in range(5,10)] -> [25, 36, 49, 64, 81] (list comprehension)

def ps(x): return x%2 == 0

filter(ps,range(5,10)) -> [6, 8]

# vagy

[x for x in range(5,10) if x%2==0] 

### Szótárak


d = { 'Béla': 2, 'Alajos': 5, 'Jolán' : 'Igazoltan hiányzik'}

d['Jolán'] -> "Igazoltan hiányzik"
d['Joli'] -> KeyError: 'Joli'
d['Joli'] = 17
d['Joli'] -> 17

dict([(x, x**2) for x in (2, 4, 6)]) -> {2: 4, 4: 16, 6: 36}


### File

#Lehet így is, de ne tegyük:

f = open('proba.txt', 'w') # lehet "r" vagy "r+" (read & write) is
f.write('1. sor 1. fele ')
f.write('1. sor 2. fele\n')
f.write('2. sor\n')
f.close()


Inkább igy, aminek egyik előnye, hogy a file
mindenkeppen be lesz zárva, akkor is, ha valami baj történik. 

with open('/tmp/proba.txt', 'w') as f:
	f.write('1. sor 1. fele ')
	f.write('1. sor 2. fele\n')
	f.write('2. sor\n')


with open('/tmp/proba.txt', 'r') as f:
	for line in f:
		print line


# read() az egeszet beolvassa (es egy stringet ad vissza)
with open('/tmp/proba.txt', 'r') as f:
	print f.read()


Es ha mar itt tartunk:

require urllib

def get_html(uri):
    u = urllib.urlopen(uri)
    return u.read()


utan lehet

get_html("http://www.google.com")


# =============
# Regular Expressions:
# =============

# attekintes: http://docs.python.org/howto/regex.html

# motto: Some people, when confronted with a problem, think 
#        "I know, I'll use regular expressions." 
#        Now they have two problems.  -- Jamie Zawinski

# kell:
import re

"pattern"

# Bonyolultabb peldak: http://docs.python.org/library/re.html
# Egyszeru peldak:

"\d\d:\d\d:\d\d"     # a time such as 12:34:56
"Perl.*Python"       # Perl, zero or more other chars, then Python
"Perl Python"        # Perl, a space, and Python
"Perl *Python"       # Perl, zero or more spaces, and Python
"Perl +Python"       # Perl, one or more spaces, and Python
"Perl\s+Python"      # Perl, whitespace characters, then Python
"Ruby (Perl|Python)" # Ruby, a space, and either Perl or Python


# Hasznalati modok:

re.search("pattern", "string") # a legelsot egyezest talalja meg es visszaad egy match objektumot vagy None-t ha nem talalt; altalaban ez kell majd nekunk
re.match("pattern", "string") # csak a string elejen kezdodo egyezest talalja meg, match objektumot ad vagy None-t
re.findall("pattern", "string") # megtalalja az osszes egyezest es az illeszkedo resz-stringekbol allo listat adja vissza
re.sub("pattern", "replace", "string") # kicsereli "replace"-re az osszes megtalaltat, majd stringet ad


# Match objektumok:

match = re.search("i.a", "cica cila")

# match.group() # az a resz-string, ami illeszkedett; altalaban ez kell nekunk
# match.group(0) # ugyanaz, de ld. kesobb a csoportositast!
# match.string # visszaadja azt amiben kerestunk


# Peldak:

# print re.sub("kut..", "cica", "A kutyat elvitte a kutya.")
# print re.findall("kut..", "A kutyat elvitte a kutya.")
# print re.findall("cic.", "A kutyat elvitte a kutya.")
# print re.search("cic.", "A kutyat elvitte a kutya.")


# Debuggolashoz hasznaljuk majd ezt:

def show_match(string, pattern):
	match = re.search(pattern, string)
	if match:
		return string[:match.start()] + "<<" + string[match.start():match.end()] + ">>" + string[match.end():]
	else:
		return "no match"

		
#------------------------------------

"""
A következő karaktereken kívül: 

. | ( ) [ ] { } + \ ^ $ * ? 

minden karakter magát jelenti.

\ : escape. megszabadítja a fenti karaktereket spciális jelentésüktől. Pl.:
    \+  szó szerint + -t jelent. show_match("13+5","\+") -> "13<<+>>5"

| : alternatíva; show_match("felsül","fel|le") -> <<fel>>sül

. : tetszőleges karakter

^ : sor elejéhez köt. Pl. show_match("alma","^lma") -> no match

$ : sor végéhez köt

[]: karakter-osztály. Intervallumo(k úniójá)t is meg lehet adni,
    pl. [B-Eb-e]; ha ^ az első karakter, akkor komplementálás jelent,
    pl.: show_match("Egy magyar nabob","[^gE]") -> Eg<<y>> magyar nabob

    Vannak spéci karakterosztályok, pl. \s (szóköz, tab, újsor és hasonlók)
    \S (\s komplementere), \d (számjegy, azaz [0-9]) \D (\d komplementere, 
    azaz [^0-9], \w = [A-Za-z0-9_], \W \w komplementere)

? + * : ismétlés
       
      ? : 0 vagy 1
      + : legalább 1
      * : akárhány

     Alapértelmezésben ezek mohók (olyan hosszú karaktersorozatra
     illeszkednek, amilyenre csak tudnak). Ezen változtat az utánuk írt '?'.
     Pl.: show_match("Egy liliputi bolha emlekei.","\s.*\s") 
             -> Egy<< liliputi bolha >>emlekei.
          show_match("Egy liliputi bolha emlekei.","\s.*?\s")
             -> Egy<< liliputi >>bolha emlekei.

(): csoportosítás

    show_match("liliput","li*") -> <<li>>liput
    show_match("liliput","(li)*") -> <<lili>>put

    De nem ez a legjobb benne. Minden csoportot meg is jegyez, és
    ezekre hivatkozhatunk (a pattern-ben - és ha helyettesítünk, akkor
    a helyettesítésben is) \1, \2,... néven. Pl.:

    show_match("Dupla szamjegy: 12345", r"(\d)\1")   -> "no match"
    show_match("Dupla szamjegy: 12335", r"(\d)\1")
                 -> "Dupla szamjegy: 12<<33>>5"
		Az r ('raw string') a "(\d)\1" elé azért kell, hogy '\'-t ne kelljen escape-elni. 'r' nélkül "(\d)\1" helyett "(\\d)\\1"-t kellene írnunk. 

    .group(i) a match objektumból az i. csoportot szedi ki (0. a teljes illeszkedő részstring):

    match = re.search(r"(\d)\1","Dupla szamjegy: 12335")
    print match.group(0) -> 33
    print match.group(1) --> 3


    \i-t a helyettesítő stringben is használhatjuk:

    print re.sub(r"(\d)", r"\1\1", "Dupla szamjegy! 12345")
                 -> "Dupla szamjegy! 1122334455"

"""

#-------------------------------

"""
sub 2. argumentuma string helyett lehet egy egyargumentumú
block is; az argumentum egy match objektumot kap, és a
helyettesítendő stringet adja vissza. Pl.:
"""
def replace(matchobj):
	return matchobj.group()*2

re.sub(r"(\d)", replace, "Dupla szamjegy! 12345")
#   -> Dupla szamjegy! 1122334455

# kommentár: string * n -> string n-szer egymásutánfűzve. Pl.:
"na"*16 + " batman!"
#   -> nananananananananananananananana batman!

# Hasznosabb pl.:

def replace2(matchobj):
	return matchobj.group().upper()

re.sub(r"\b(\w)", replace2, "dupla számjegy") # -> "Dupla SzßMjegy"

# kommentár: \b "word boundary"; hogy 'á' miért minősül annak, vagy hogy
# mi más történik itt, az az eheti rejtély. (meg a múltévi is)