Matematikai Algoritmusok és Felfedezések I.

4. Előadás: Comprehensions, Objektum orientált programozás

2021 március 1.

List comprehension

• Flat is better than nested.
• Rövidités a foor loop leggyakoribb használatára, hogy gyorsan tudjunk listákat létrehozni

l = []
for i in range(10):
    l.append(2*i+1)
l

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

Egy soros megfelelő:

l = [2*i+1 for i in range(10)]
l

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

Az általános formula

[<expression> for <element> in <sequence>]

even = [n*n for n in range(20) if n % 2 == 0]
even

[0, 4, 16, 36, 64, 100, 144, 196, 256, 324]

Ami azzal ekvivalens, hogy

even = []
for n in range(20):
    if n % 2 == 0:
        even.append(n)
even

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

egy feltételt is megadhatunk, hogy szűrjük az elemeket:

[<expression> for <element> in <sequence> if <condition>]

• mivel itt szűrésre használjuk az if részt, nincs else ág

• viszont a kezdeti kifejezésben használhatunk esetszétválasztást:

l = [1, 0, -2, 3, -1, -5, 0]

signum_l = [int(n / abs(n)) if n != 0 else 0 for n in l]
signum_l

[1, 0, -1, 1, -1, -1, 0]

Ez persze nem a list comprehension extrája, hanem csak annyi, hogy ez is egy értelmes kifejezés:

n = -3.2 
int(n / abs(n)) if n != 0 else 0 

-1

Több listán is végigfuthatunk:

l1 = [1, 2, 3]
l2 = [4, 5, 6]

[(i, j) for i in l1 for j in l2]

[(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]

Egymásba is ágyazhatjuk őket:

matrix = [
    [1, 2, 3], 
    [5, 6, 7]
]

[[e*e for e in row] for row in matrix]

[[1, 4, 9], [25, 36, 49]]

Set és dictionary comprehension

Minden analóg módon működik:

fruit_list = ["apple", "plum", "apple", "pear"]

fruits = {fruit.title() for fruit in fruit_list}

type(fruits), len(fruits), fruits

(set, 3, {'Apple', 'Pear', 'Plum'})

word_list = ["apple", "plum", "pear"]
word_length = {word: len(word) for word in word_list}
type(word_length), len(word_length), word_length

(dict, 3, {'apple': 5, 'plum': 4, 'pear': 4})

Vajon mi történik?

word_list = ["apple", "plum", "pear", "avocado"]
first_letters = {word[0]: word for word in word_list}
first_letters

{'a': 'avocado', 'p': 'pear'}

Függvények fura viselkedése

def furcsafuggveny(l):
    k = []
    l = k
l = [1,2,3]
furcsafuggveny(l)
print(l)

[1, 2, 3]

def furcsafuggveny2(l):
    l.append(4)
    l += [5]
    l = l + [6]
    l.append(7)
l = [1,2,3]
furcsafuggveny2(l)
print(l)
#Result: [1, 2, 3, 4, 5]

[1, 2, 3, 4, 5]

a=5
def f():
    print(a)
f()

5

a=5
def f():
    global a
    a=a+1
    print(a)
f()

6

Namespace (névtér)

A namespace a változó nevek és az objektumok közti leképezés (pont mint egy dictionary). Pl:

• beépített nevekhez (abs(), sorted(), int stb...) tartozik egy namespace
• globális namespace: ide kerülnek a függvényeken kívül létrehozott változók

• lokális namespece: minden függvény létrehoz egy saját namespacet, először abban keres

  Különböző namespacekben szerepelhet egyező név!

# Ez egy szándékosan zavaróan megírt kód. 
a=5                       # a globális namespaceben 'a' az 5-re fog mutatni
def foo(a):               # ez már egy másik `a`, ami a foo() függvény namespaceben él
    print(a+1)            # itt a foo()-hoz tartozó 'a'-ra hivatkozunk.   
    def belsofugveny(a):  # ez egy harmadik 'a' változó, ez már a belsofugveny()-hez tartozik
        print(a+5);       # itt a belsofugveny()-hez tartozó 'a'-ra hivatkozunk.  
    belsofugveny(a)       # itt a foo()-hoz tartozó 'a'-ra hivatkozunk.    
   
foo(10)
a                         # itt a globális 'a'-ra hivatkozunk.   

11
15

5

Scope

Minden namespacehez tartozik egy scope. A scope a kódnak az a része, ahol a neveket automatikusan abban az adott namespaceben keresi a program.

a=5                       #
                          #
def foo(a):                   # 
    print(a+1)                #    
                              #   
    def belsofugveny(a):          # 
        print(a+5);               #
                              #
    belsofugveny(a)           # 
                          #
foo(10)                   #  
a                         #    

Hogyan érjük el egy másik namespaceben lévő objektumokat?

• a python kifelé keres, először a legbelső namespaceben
• nonlocal valnev megmondja, hogy eggyel kintebbi scopeban keressen. (Pontosabban, a "legutóbbi" nem lokális használatot keresi)
• global valnev megmondja, hogy a globális scopeban keressen.

def scope_test():
    def do_local():
        spam = "local spam"

    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam" 

    def do_global():
        global spam
        spam = "global spam"

    spam = "test spam"
    do_local()
    print("lokális értékadás után:", spam)
    do_nonlocal()
    print("nonlocal kulcsszó után:", spam)
    do_global()
    print("global kulcsszó után:", spam)

scope_test()
print("globális scopeban:", spam)

lokális értékadás után: test spam
nonlocal kulcsszó után: nonlocal spam
global kulcsszó után: nonlocal spam
globális scopeban: global spam

A másik lehetőség, hogy megadjuk, hogy melyik namespaceben kell keresni.

import math
math.pi           # a math modul namespaceben keresi a pi nevű változót

Programozási paradigmák

Sokféle van, például:

• Procedurális
• Funckionális
• Objektumorientált

Példa: Főzés vs matek vs autók

Mikor melyiket válasszuk?

Python

• többféle stílusban is lehet használni, a fentiek mindegyikét tudja többé kevésbé
• sokszor vegyesen is használjuk
• erősen támogatja az objektumorientált paradigmát. Minden objektum!

# minden objektum
import random
def foo():
    pass
[int,bool,foo,random] 

[int,
 bool,
 <function __main__.foo()>,
 <module 'random' from 'c:\\users\\user\\anaconda3\\envs\\clean2021\\lib\\random.py'>]

Objektumorientált programozás

• Osztályok: A programot objektumok köré szervezzük. Minden objektum tartalmaz adatokat és metódusokat, amik az adatokat kezelik.
• Öröklődés (Inheritance): Specifikusabb objektumokat hozhatunk létre, melyek öröklik a korábbiak tulajdonságait
• Egységbezárás (Encapsulation): Az összetartozó adatokat és metódusokat együtt kezeljük.
• Absztrakció (Abstraction): A belső működést elrejtjük és csak a szükséges részt mutatjuk meg a felhasználónak.
• Polimorfizmus (Polymorphism): A leszármazottak és példányok felülírhatják a metódusokat. Több osztályból is örököltethetünk egyszerre.

Objektum orientáltság Pythonban

https://docs.python.org/3/tutorial/classes.html

Osztály (class) definiálása

• class kulcsszóval
• példányokat tudunk létrehozni
• minden példánynak van egy saját namespace
• attribútumokat tudunk kapcsolni hozzájuk melyek nem befolyásolják a többi példány attribútumait

class Ember:
    pass

a=Ember()
print(type(a))
a.nev="Gipsz Jakab"
a.kor=24
b=Ember()
b.nev="Gipsz Jakabné"
b.kor=22
c=Ember()
c.nev="Mezga Aladár"
c.kor=23
l=[a,b,c]
for e in l:
    print(e.nev,e.kor)

<class '__main__.Ember'>
Gipsz Jakab 24
Gipsz Jakabné 22
Mezga Aladár 23

type(a)

__main__.Ember

Init

• __init__ függvény automatikusan meghívódik amikor a példány elkészül.
  • olyasmi mint egy konstruktor
  • nem kötelező
• minden metódus első paramétere maga a példány. Ezt megszokásból self-nek hívjuk.

class Ember:
    def __init__(self,nevasd,kor):
        print("Létrejött egy ember")
        self.kor = kor
        self.nev = nevasd
 

a=Ember("Gipsz Jakab",24)
b=Ember("Gipsz Jakabné",22)

l=[a,b]
for e in l:
    print(e.nev,e.kor)

Létrejött egy ember
Létrejött egy ember
Gipsz Jakab 24
Gipsz Jakabné 22

Metódusok

• Függvények az osztály definíciójában
• Automatikusan az első argumentumuk a példány lesz.

class Ember:
    def __init__(self,nev,kor):
        self.kor = kor
        self.nev = nev
        
    def szuletesi_ev(self):    # egy paramétert vár
        print(2021-self.kor)
        
    def egykoru(self,other):    
        print(self.kor==other.kor)
 
    
a=Ember("Gipsz Jakab",24)
a.szuletesi_ev()                # de paraméter nélkül hívjuk meg, mivel az első paraméter maga 'a' lesz  
b=Ember("Gipsz Jakabné",22)
a.egykoru(b)

1997
False

Metódusok meghívása

Két lehetőség van:

1. példány.metódus(param)
2. class.metódus(példány, param)

a=Ember("Gipsz Jakab",24)
a.szuletesi_ev()                
Ember.szuletesi_ev(a)

1997
1997

__str__ metódus

Egy speciális metódus, amit arra használunk hogy megadjuk, hogy a print() függvény hogyan írja ki az objektumot.

print(a)
print(1+4j)

<__main__.Ember object at 0x0000024F3F529208>
(1+4j)

class Ember:
    def __init__(self,nev,kor,lakohely):
        self.kor = kor
        self.nev = nev
        self.lakohely = lakohely
    def __str__(self): 
        return self.nev+" egy "+str(self.kor)+" éves "+ self.lakohely + "i lakos."
    
a=Ember("Gipsz Jakab",24,"budapest")
print(a)
b=Ember("Gipsz Jakabné",22,"kecskemét")
print(b)

Gipsz Jakab egy 24 éves budapesti lakos.
Gipsz Jakabné egy 22 éves kecskeméti lakos.

Osztály attribútumok

• Olyan attribútum, amin az ossztály összes tagja osztozik.

class Ember:
    letszam = 42

A példányokon és a class objektumon keresztül is elérjük

a = Ember()
a.letszam

42

Ember.letszam

42

Megváltoztatni a classon keresztül lehet

a1 = Ember()
a2 = Ember()

print(a1.letszam,a2.letszam)
a1.letszam = 43
a1.letszam, a2.letszam

42 42

(43, 42)

A példányokon keresztül viszont nem

a1 = Ember()
a2 = Ember()

a1.letszam = 11
a1.letszam , a2.letszam

(11, 42)

Azért, mert ez egy új attribútumot hoz létre a példány namespacében.

a1.letszam

11