Második túra a Sage-ben

Listák

range(-tól=0, -ig, lépésköz=1)
[ ) intervallum! A nulla az első index!

In [1]:
range(5, 10)
Out[1]:
[5, 6, 7, 8, 9]
In [2]:
[1, 2, 3][0] == 1
Out[2]:
True

Lista értelmezés

[ f(x) for x in ___ ]

In [3]:
[n for n in range(10)]
Out[3]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [4]:
[n^2 for n in range(1,11)]
Out[4]:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

kiválasztás

[ f(x) for x in ___ if g(x) ]
f(x) az eredmény, g(x) egy igaz/hamis feltétel.

vagy-vagy

[ f1(x) if g(x) else f2(x) for x in ___ ]
Mindegyik elem belekerül, de választható értékkel.

In [5]:
print range(1,21)
[ 3*x+1 if x%2==1 else x//2 for x in range(1,21) ]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
Out[5]:
[4, 1, 10, 2, 16, 3, 22, 4, 28, 5, 34, 6, 40, 7, 46, 8, 52, 9, 58, 10]

Több for

Descartes szorzatot jelent
[(i,j) for i in ___ for j in ___ ]
párokon megy végig.

Nem ugyan az, mint
[[(i,j) for i in ___ ] for j in ___ ]
Mert ez egymásba ágyazott lista.

In [6]:
print([ (i, j) for i in range(5) for j in range(5) ] )
print
print([[ (i, j) for i in range(5)] for j in range(5) ] )
[(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4)]

[[(0, 0), (1, 0), (2, 0), (3, 0), (4, 0)], [(0, 1), (1, 1), (2, 1), (3, 1), (4, 1)], [(0, 2), (1, 2), (2, 2), (3, 2), (4, 2)], [(0, 3), (1, 3), (2, 3), (3, 3), (4, 3)], [(0, 4), (1, 4), (2, 4), (3, 4), (4, 4)]]

Függvények

sorközi:
f(x) = x^2
vagy kiemelt:
def f(x):
return x^2
Fontos a kettőspont és az identálás. Az identálásból derül ki, hogy mi tartozik még a függvényhez és mi van már rajta kívül (nincsen end).
return</strong> nem feltétlenül a legutolsó parancs, de utána már nem fut le semmi.

In [7]:
x=var('x')
f(x)=x^2
def g(x):
    return x^2
def h(x):
    return x^2
    print('elfelejtettem!')
# def h2(x):
# return x^2
print(f(3), g(3))
print(diff(f,x,1))
print(diff(g(x),x,1))
(9, 9)
x |--> 2*x
2*x

sorközi függvény (f(x) = ...) mást tud, azok a matematikai értelemben vett függvények, a kiemelt (def) a programozás értelemben vett függvények.

In [8]:
f?

Elágazás

sorközi:
f1(x) if g(x) else f2(x)
vagy kiemelt:
if g(x):
f1(x)
else:
f2(x)

Fontos a kettőspont és az identálás. Az else opcionális.

In [9]:
def paritas(a):
    if a%2 == 0:
        return "páros"
    else:
        return "páratlan"
    return 0
print(paritas(5))
páratlan

Ha nincs return egy kiemelt függvénxben, akkor értéke egy egyedi None érték.
Nem kiemelt függvény nem tud nem adni értéket, mert különben error-t kapunk!

In [10]:
def paritas2(a):
    if a%2 == 0:
        return "páros"
    else:
        print "páratlan"
    'jajj'
print(paritas2(5))
páratlan
None
In [11]:
def lnko(a,b):
    if (b == 0):
        return a
    return lnko(b, a%b)
print(lnko(50,15))
5
In [12]:
def faktor(n):
    if n==0:
        return 1
    return n*faktor(n-1)
faktor(10)
Out[12]:
3628800
In [13]:
def faktor2(x):
    return x*faktor2(x-1)
faktor2(10)
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-13-6cba3e7d3469> in <module>()
      1 def faktor2(x):
      2     return x*faktor2(x-Integer(1))
----> 3 faktor2(Integer(10))

<ipython-input-13-6cba3e7d3469> in faktor2(x)
      1 def faktor2(x):
----> 2     return x*faktor2(x-Integer(1))
      3 faktor2(Integer(10))

... last 1 frames repeated, from the frame below ...

<ipython-input-13-6cba3e7d3469> in faktor2(x)
      1 def faktor2(x):
----> 2     return x*faktor2(x-Integer(1))
      3 faktor2(Integer(10))

RuntimeError: maximum recursion depth exceeded while calling a Python object

Hanoi tornyai

A játékot 1883-ban Édouard Lucas francia matematikus találta fel. Az ötletet egy legendából kapta, ami szerint a világ megteremtésekor egy 64 korongból álló hanoi torony feladványt kezdtek el „játszani” Brahma szerzetesei. A szabályok azonosak voltak a ma ismert hanoi torony szabályaival. A legenda szerint, amikor a szerzetesek végeznek majd a korongok átjuttatásával a harmadik rúdra, a kolostor összeomlik, és a világunk megszűnik létezni.
Wikipédia

In [14]:
A = [5, 4, 3, 2, 1]
B = []
C = []
def move(n, source, target, auxiliary):
    if n > 0:
        # move n - 1 disks from source to auxiliary, so they are out of the way
        move(n - 1, source, auxiliary, target)
        # move the nth disk from source to target
        target.append(source.pop())
        # Display our progress
        print(A, B, C)
        # move the n - 1 disks that we left on auxiliary onto target
        move(n - 1, auxiliary, target, source)
# initiate call from source A to target C with auxiliary B
move(5, A, C, B)
([5, 4, 3, 2], [], [1])
([5, 4, 3], [2], [1])
([5, 4, 3], [2, 1], [])
([5, 4], [2, 1], [3])
([5, 4, 1], [2], [3])
([5, 4, 1], [], [3, 2])
([5, 4], [], [3, 2, 1])
([5], [4], [3, 2, 1])
([5], [4, 1], [3, 2])
([5, 2], [4, 1], [3])
([5, 2, 1], [4], [3])
([5, 2, 1], [4, 3], [])
([5, 2], [4, 3], [1])
([5], [4, 3, 2], [1])
([5], [4, 3, 2, 1], [])
([], [4, 3, 2, 1], [5])
([1], [4, 3, 2], [5])
([1], [4, 3], [5, 2])
([], [4, 3], [5, 2, 1])
([3], [4], [5, 2, 1])
([3], [4, 1], [5, 2])
([3, 2], [4, 1], [5])
([3, 2, 1], [4], [5])
([3, 2, 1], [], [5, 4])
([3, 2], [], [5, 4, 1])
([3], [2], [5, 4, 1])
([3], [2, 1], [5, 4])
([], [2, 1], [5, 4, 3])
([1], [2], [5, 4, 3])
([1], [], [5, 4, 3, 2])
([], [], [5, 4, 3, 2, 1])