Informatika1-2012/Eloadas3

A MathWikiből
(Változatok közti eltérés)
(Új oldal, tartalma: „<h1>Beépített függvények</h1> <h1>Összetett adattípusokon általánosan értelmezett függvények</h1> <table style="margin-left: auto; margin-right: auto; borde…”)
 
 
(egy szerkesztő 2 közbeeső változata nincs mutatva)
15. sor: 15. sor:
 
<h1>Reference</h1>
 
<h1>Reference</h1>
  
−
<table style="width:1000px;">
+
<table>
−
   <tr><td style="width:450px"><ul><li><code>add(&lt;item&gt;)</code></li></ul></td><td>– új elem hozzáadása</td></tr>
+
   <tr><td><ul><li><code>add(&lt;item&gt;)</code></li></ul></td><td>– új elem hozzáadása</td></tr>
−
   <tr><td colspan="2"><ul><li><code>insert(&lt;index&gt;,&lt;item&gt;)</code></li></ul></td></tr>
+
   <tr><td><ul><li><code>insert(&lt;index&gt;,&lt;item&gt;)</code></li></ul></td><td>– új elem beillesztése</td></tr>
−
  <tr><td></td><td>– új elem beillesztése</td></tr>
+
 
   <tr><td><ul><li><code>append(&lt;item&gt;)</code></li></ul></td><td>– új elem hozzáfűzése</td></tr>
 
   <tr><td><ul><li><code>append(&lt;item&gt;)</code></li></ul></td><td>– új elem hozzáfűzése</td></tr>
 
   <tr><td><ul><li><code>remove(&lt;item&gt;)</code></li></ul></td><td>– elem törlése</td></tr>
 
   <tr><td><ul><li><code>remove(&lt;item&gt;)</code></li></ul></td><td>– elem törlése</td></tr>
 
   <tr><td><ul><li><code>clear()</code></li></ul></td><td>– gyűjtemény kiürítése</td></tr>
 
   <tr><td><ul><li><code>clear()</code></li></ul></td><td>– gyűjtemény kiürítése</td></tr>
 
   <tr><td><ul><li>S: <code>pop()</code><br/>L: <code>pop([&lt;index&gt;])</code><br/>
 
   <tr><td><ul><li>S: <code>pop()</code><br/>L: <code>pop([&lt;index&gt;])</code><br/>
−
           D: <code>pop(&lt;key&gt;[, dv])</code></li></ul></td><td style="vertical-align:top; position : relative; left: 2em; text-indent: -2em;">– egy elem visszaadása és törlése a gyüjteményből</td></tr>
+
           D: <code>pop(&lt;key&gt;[, dv])</code></li></ul></td><td>– egy elem visszaadása és törlése a gyüjteményből</td></tr>
−
</table>
+
   <tr><td colspan="2"><ul><li><code>index(&lt;item&gt;[, start [, stop]])</code></li></ul></td></tr><tr><td></td><td>– elem indexe, ha tartalmazza</td></tr>
−
 
+
   <tr><td><ul><li><code>count(&lt;item&gt;)</code></li></ul></td><td>– megszámolja és visszatér, hogy hányszor tartalmazza a gyűjtemény az adott elemet</td></tr>
−
<table style="width:1000px;">
+
−
   <tr><td colspan="2"><ul><li><code>index(&lt;item&gt;[, start [, stop]])</code></li></ul></td></tr><tr><td></td><td style="vertical-align:top; position : relative; left: 2em; text-indent: -2em;">– elem indexe, ha tartalmazza</td></tr>
+
−
   <tr><td><ul><li><code>count(&lt;item&gt;)</code></li></ul></td><td style="vertical-align:top; position : relative; left: 2em; text-indent: -2em;">– megszámolja és visszatér, hogy hányszor tartalmazza a gyűjtemény az adott elemet</td></tr>
+
 
   <tr><td><ul><li><code>copy()</code></li></ul></td><td>– gyűjtemény lemásolása</td></tr>
 
   <tr><td><ul><li><code>copy()</code></li></ul></td><td>– gyűjtemény lemásolása</td></tr>
 
   <tr><td><ul><li><code>len(&lt;coll&gt;)</code></li></ul></td><td>– gyűjtemény hossza</td></tr>
 
   <tr><td><ul><li><code>len(&lt;coll&gt;)</code></li></ul></td><td>– gyűjtemény hossza</td></tr>
34. sor: 30. sor:
  
 
<h1>Halmazok függvényei</h1>
 
<h1>Halmazok függvényei</h1>
−
<code>set = set([pi, 'abc', 35, pi])</code>
+
<p><code>S = set([pi, 'abc', 35, pi])</code></p>
  
 
<ul>
 
<ul>
−
   <li><code>union(&lt;coll&gt;[, &lt;coll&gt;]*)</code></li>
+
   <li><code>union(&lt;coll&gt;[, &lt;coll&gt;]*)</code><br/>egyesíti a halmazokat, az eredménnyel visszatér</li>
−
  <ul><li style="list-style-type:none; text-indent: -1em;">– egyesíti a halmazokat, az eredménnyel visszatér</li></ul>
+
   <li><code>update(&lt;coll&gt;[, &lt;coll&gt;]*)</code><br/>union - az eredmény bekerül az "első" halmazba (|=)</li>
−
   <li><code>update(&lt;coll&gt;[, &lt;coll&gt;]*)</code></li>
+
   <li><code>intersection(&lt;coll&gt;[, &lt;coll&gt;]*)</code>,<br/><code>intersection_update(&lt;coll&gt;[, &lt;coll&gt;]*)</code><br/>
−
  <ul><li style="list-style-type:none; text-indent: -1em;">– union - az eredmény bekerül az "első" halmazba (|=)</li></ul>
+
    visszaadja a közös részt ill. halmaz felülírása az eredménnyel (&, &=)</li>
−
   <li><code>intersection(&lt;coll&gt;[, &lt;coll&gt;]*)</code>,<br/><code>intersection_update(&lt;coll&gt;[, &lt;coll&gt;]*)</code></li>
+
   <li><code>difference(&lt;coll&gt;[, &lt;coll&gt;]*)</code>,<br/><code>difference_update&lt;coll&gt;[, &lt;coll&gt;]*)</code><br/>
−
  <ul><li style="list-style-type:none; text-indent: -1em;">– visszaadja a közös részt ill. halmaz felülírása az eredménnyel (&, &=)</li></ul>
+
    különbség visszaadása ill. halmaz felülírása az eredménnyel (-, -=)</li>
−
   <li><code>difference(&lt;coll&gt;[, &lt;coll&gt;]*)</code>,<br/><code>difference_update&lt;coll&gt;[, &lt;coll&gt;]*)</code></li>
+
   <li><code>discard(&lt;item&gt;), remove(&lt;item&gt;)</code><br/>elem törlése a halmazból, remove esetén hiba, ha nem létezik</li>
−
  <ul><li style="list-style-type:none; text-indent: -1em;">– különbség visszaadása ill. halmaz felülírása az eredménnyel (-, -=)</li></ul>
+
   <li><code>isdisjoint(coll)</code><br/>igaz, ha nincs közös elemük</li>
−
   <li><code>discard(&lt;item&gt;), remove(&lt;item&gt;)</code></li>
+
   <li><code>issubset(&lt;coll&gt;)</code><br/>részhalmaza-e a paraméter (&lt;, &lt;=)</li>
−
  <ul><li style="list-style-type:none; text-indent: -1em;">– elem törlése a halmazból, remove esetén hiba, ha nem létezik</li></ul>
+
   <li><code>issuperset(&lt;coll&gt;)</code><br/>a halmaz részhalmaza-e a paraméternek (&gt;, &gt;=)</li>
−
   <li><code>isdisjoint(coll)</code></li>
+
−
  <ul><li style="list-style-type:none; text-indent: -1em;">– igaz, ha nincs közös elemük</li></ul>
+
−
   <li><code>issubset(&lt;coll&gt;)</code></li>
+
−
  <ul><li style="list-style-type:none; text-indent: -1em;">– részhalmaza-e a paraméter (&lt;, &lt;=)</li></ul>
+
−
   <li><code>issuperset(&lt;coll&gt;)</code></li>
+
−
  <ul><li style="list-style-type:none; text-indent: -1em;">– a halmaz részhalmaza-e a paraméternek (&gt;, &gt;=)</li></ul>
+
 
</ul>
 
</ul>
  
 
<h1>Lista függvényei</h1>
 
<h1>Lista függvényei</h1>
−
<code>list = ['a', 'orange', 1, 1.56]</code>
+
<p><code>L = ['a', 'orange', 1, 1.56]</code></p>
 
<ul>
 
<ul>
−
   <li><code>sort([cmp=None,] [key=None,] [reverse=False])</code></li>
+
   <li><code>sort([cmp=None,] [key=None,] [reverse=False])</code><br/>rendezi a lista elemeit</li>
−
  <ul><li style="list-style-type:none; text-indent: -1em;">– rendezi a lista elemeit</li></ul>
+
   <li><code>extend(&lt;coll&gt;)</code><br/>hozzáadja a paraméterként átadott gyűjtemény elemeit a listához (+)</li>
−
   <li><code>extend(&lt;coll&gt;)</code></li>
+
   <li><code>reverse()</code><br/>megfordítja a lista elemeinek sorrendjét</li>
−
  <ul><li style="list-style-type:none; text-indent: -1em;">– hozzáadja a paraméterként átadott gyűjtemény elemeit a listához (+)</li></ul>
+
   <li>* operator<br/>lemásolja és összefűzi újra a lista elemeit</li>
−
   <li><code>reverse()</code></li>
+
</ul>
−
  <ul><li style="list-style-type:none; text-indent: -1em;">– megfordítja a lista elemeinek sorrendjét</li></ul>
+
−
   <li>* operator</li>
+
−
  <ul><li style="list-style-type:none; text-indent: -1em;">– lemásolja és összefűzi újra a lista elemeit</li>
+
−
  </ul>
+
  
−
  <h1>Szótár függvényei</h1>
+
<h1>Szótár függvényei</h1>
−
  <code>D = {'a':4, 'orange':5, 1:5, 1.56:5.67}</code>
+
<code>D = {'a':4, 'orange':5, 1:5, 1.56:5.67}</code>
  
−
  <ul>
+
<ul>
−
    <li><code>get(&lt;key&gt;[, &lt;dv&gt;])</code></li>
+
  <li><code>get(&lt;key&gt;[, &lt;dv&gt;])</code><br/>a kulcshoz tartozó értékkel tér vissza, ha létezik;<br/>
−
    <ul><li style="list-style-type:none; text-indent: -1em;">– a kulcshoz tartozó értékkel tér vissza, ha létezik;<br/>
+
    egyébként <code>None</code> ill. <code>dv</code>, ha megadtuk</li>
−
        egyébként <code>None</code> ill. <code>dv</code>, ha megadtuk</li></ul>
+
  <li><code>has_key(&lt;key&gt;)</code><br/>igaz, ha a szótár eleme a kulcs</li>
−
    <li><code>has_key(&lt;key&gt;)</code></li>
+
  <li><code>items()</code><br/>a szótár elemeit adja vissza egy listában (kulcs, érték) tuple formajában</li>
−
    <ul><li style="list-style-type:none; text-indent: -1em;">– igaz, ha a szótár eleme a kulcs</li></ul>
+
  <li><code>keys()</code><br/>a kulcsokat adja vissza egy listában</li>
−
    <li><code>items()</code></li>
+
  <li><code>iterkeys()</code><br/>szótár kulcsain lépkedő iterátorral tér vissza</li>
−
    <ul><li style="list-style-type:none; text-indent: -1em;">– a szótár elemeit adja vissza egy listában (kulcs, érték) tuple formajában</li></ul>
+
  <li><code>iteritems()</code><br/>szótár értékein lépkedő iterátorral tér vissza</li>
−
    <li><code>keys()</code></li>
+
  <li><code>popitem()</code><br/>szótár egy elemét eltávolítja és visszaadja (kulcs, érték) tuple formájában</li>
−
    <ul><li style="list-style-type:none; text-indent: -1em;">– a kulcsokat adja vissza egy listában</li></ul>
+
  <li><code>update(&lt;coll&gt;)</code><br/>dict vagy tuple lista elemeit illeszti be a szótárba</li>
−
    <li><code>iterkeys()</code></li>
+
  <li><code>setdefault(&lt;key&gt;[, value])</code><br/>beilleszti az elemet és visszatér az értékkel</li>
−
    <ul><li style="list-style-type:none; text-indent: -1em;">– szótár kulcsain lépkedő iterátorral tér vissza</li></ul>
+
  <li><code>values()</code><br/>visszatér az értékekből képzett listával</li>
−
    <li><code>iteritems()</code></li>
+
</ul>
−
    <ul><li style="list-style-type:none; text-indent: -1em;">– szótár értékein lépkedő iterátorral tér vissza</li></ul>
+
−
    <li><code>popitem()</code></li>
+
−
    <ul><li style="list-style-type:none; text-indent: -1em;">– szótár egy elemét eltávolítja és visszaadja (kulcs, érték) tuple formájában</li></ul>
+
−
    <li><code>update(&lt;coll&gt;)</code></li>
+
−
    <ul><li style="list-style-type:none; text-indent: -1em;">– dict vagy tuple lista elemeit illeszti be a szótárba</li></ul>
+
−
    <li><code>setdefault(&lt;key&gt;[, value])</code></li>
+
−
    <ul><li style="list-style-type:none; text-indent: -1em;">– beilleszti az elemet és visszatér az értékkel</li></ul>
+
−
    <li><code>values()</code></li>
+
−
    <ul><li style="list-style-type:none; text-indent: -1em;">– visszatér az értékekből képzett listával</li></ul>
+
−
  </ul>
+
  
−
  <h1>Függvények számításokhoz</h1>
+
<h1>Függvények számításokhoz</h1>
  
−
  <ul>
+
<ul>
−
    <li><code>var(&lt;string&gt;)</code></li>
+
  <li><code>var(&lt;string&gt;)</code><br/>szimbolikus számításokhoz hozhatunk létre változókat</li>
−
    <ul><li style="list-style-type:none; text-indent: -1em;">– szimbolikus számításokhoz hozhatunk létre változókat</li></ul>
+
  <li><code>subs(&lt;args&gt;)</code><br/>kifejezés függvénye, amivel behelyettesíthetjük a változókat a
−
    <li><code>subs(&lt;args&gt;)</code></li>
+
    paraméterben felsorolt értékekkel és visszakapjuk a kifejezés numerikus eredményét</li>
−
    <ul><li style="list-style-type:none; text-indent: -1em;">– kifejezés függvénye, amivel behelyettesíthetjük a változókat a paraméterben felsorolt értékekkel és visszakapjuk a kifejezés numerikus eredményét</li></ul>
+
  <li><code>float(&lt;kif|num|string&gt;)</code><br/>lebegőpontos számmá próbálja alakítani a megadott paramétert (lsd. RR, RDF)</li>
−
    <li><code>float(&lt;kif|num|string&gt;)</code></li>
+
  <li><code>n()</code><br/>kifejezések függvénye, a kiértékelt kifejezést adja vissza</li>
−
    <ul><li style="list-style-type:none; text-indent: -1em;">– lebegőpontos számmá próbálja alakítani a megadott paramétert (lsd. RR, RDF)</li></ul>
+
  <li><code>exp(3)</code><br/>e<span style=" font-size:70%; vertical-align: 0.4em;">3</span></li>
−
    <li><code>n()</code></li>
+
  <li><code>pow(x,z)</code><br/>x<span style=" font-size:70%; vertical-align: 0.4em;">z</span></li>
−
    <ul><li style="list-style-type:none; text-indent: -1em;">– kifejezések függvénye, a kiértékelt kifejezést adja vissza</li></ul>
+
  <li><code>log(exp(3))</code> – természetes alapú log<br/>3</li>
−
    <li><code>exp(3)</code></li>
+
  <li><code>sqrt(16)</code> – négyzetgyök<br/>4</li>
−
    <ul><li style="list-style-type:none; text-indent: -1em;">e<span style=" font-size:70%; vertical-align: 0.4em;">3</span></li></ul>
+
  <li><code>sin(pi)</code>, <code>cos(pi)</code>, <code>tan(pi)</code> – szögfüggvények<br/><code>arcsin()</code>, ... – inverzeik</li>
−
    <li><code>pow(x,z)</code></li>
+
  <li><code>floor(4.5)</code> – alsó egészrész<br/>4</li>
−
    <ul><li style="list-style-type:none; text-indent: -1em;">x<span style=" font-size:70%; vertical-align: 0.4em;">z</span></li></ul>
+
  <li><code>ceil(4.6)</code> – felső egészrész<br/>5</li>
−
    <li><code>log(exp(3))</code> – természetes alapú log</li>
+
</ul>
−
    <ul><li style="list-style-type:none; text-indent: -1em;">3</li></ul>
+
−
    <li><code>sqrt(16)</code> – négyzetgyök</li>
+
−
    <ul><li style="list-style-type:none; text-indent: -1em;">4</li></ul>
+
−
    <li><code>sin(pi)</code>, <code>cos(pi)</code>, <code>tan(pi)</code> – szögfüggvények</li>
+
−
    <ul><li style="list-style-type:none; text-indent: -1em;"><code>arcsin()</code>, ... – inverzeik</li></ul>
+
−
    <li><code>floor(4.5)</code> – alsó egészrész</li>
+
−
    <ul><li style="list-style-type:none; text-indent: -1em;">4</li></ul>
+
−
    <li><code>ceil(4.6)</code> – felső egészrész</li>
+
−
    <ul><li style="list-style-type:none; text-indent: -1em;">5</li></ul>
+
−
  </ul>
+
  
−
  <h1>Egyenlőség vizsgálata lebegőpontos számok esetén</h1>
+
<h1>Egyenlőség vizsgálata lebegőpontos számok esetén</h1>
−
  <p>Fontos megjegyezni, hogy a lebegőpontos számok mindig közelítő értékek, így két lebegőpontos szám, ami pl. számítás
+
<p>Fontos megjegyezni, hogy a lebegőpontos számok mindig közelítő értékek, így két lebegőpontos szám, ami pl. számítás
−
    eredménye, valószínűleg nem egyezik meg egymással!</p>
+
  eredménye, valószínűleg nem egyezik meg egymással!</p>
−
  <pre><code contenteditable style="margin-top: 20px;"><span style="color: #ff4040;">sage:</span> sqrt(4.0)^2 == 4.0
+
<pre>sage: sqrt(4.0)^2 == 4.0
−
True</code></pre>
+
True</pre>
−
  DE
+
<p>DE</p>
−
  <pre><code contenteditable style="margin-top: 20px;"><span style="color: #ff4040;">sage:</span> sqrt(5.0)^2 == 5.0
+
<pre>sage: sqrt(5.0)^2 == 5.0
−
False</code></pre>
+
False</pre>
−
  <p>Megoldás:</p>
+
<p>Megoldás:</p>
−
  <pre><code contenteditable style="margin-top: 20px;"><span style="color: #ff4040;">sage:</span> abs(sqrt(5.0)^2 == 5.0) < 10<span style=" font-size:70%; vertical-align: 0.4em;">10</span>
+
<pre>sage: abs(sqrt(5.0)^2 == 5.0) < 10^(-10)
−
True</code></pre>
+
True</pre>
  
−
  <h1>Kifejezeséken használt függvények</h1>
+
<h1>Kifejezeséken használt függvények</h1>
  
−
  <p>Az algebrai kifejezeséket összeggé alakíthatjuk az <code>expand()</code>
+
<p>Az algebrai kifejezeséket összeggé alakíthatjuk az <code>expand()</code>
−
    függvénnyel vagy <code>.expand()</code> metódussal, ill. szorzattá a <code>.factor()</code>-ral:</p>
+
  függvénnyel vagy <code>.expand()</code> metódussal, ill. szorzattá a <code>.factor()</code>-ral:</p>
−
  <pre><code contenteditable style="margin-top: 20px;"><span style="color: #ff4040;">sage:</span> a,b = var('a','b')
+
<pre>sage: a,b = var('a','b')
−
<span style="color: #ff4040;">sage:</span> expand((a+b)^2)
+
sage: expand((a+b)^2)
−
a^2+2*a*b+b^2</code></pre>
+
a^2+2*a*b+b^2</pre>
−
  <pre><code contenteditable style="margin-top: 20px;"><span style="color: #ff4040;">sage:</span> x = var('x')
+
<pre>sage: x = var('x')
−
<span style="color: #ff4040;">sage:</span> (x^2-1).factor()
+
sage: (x^2-1).factor()
−
(x-1)*(x+1)</code></pre>
+
(x-1)*(x+1)</pre>
  
−
  <p>A kifejezéseket a <code>simplify()</code> vagy a <code>full_simplify()</code> metódussal tudjuk egyszerűsíteni:</p>
+
<p>A kifejezéseket a <code>simplify()</code> vagy a <code>full_simplify()</code> metódussal tudjuk egyszerűsíteni:</p>
−
  <pre><code contenteditable style="margin-top: 20px;"><span style="color: #ff4040;">sage:</span> p,x = var('p','x')
+
<pre>sage: p,x = var('p','x')
−
<span style="color: #ff4040;">sage:</span> t = p/pow(p,x)
+
sage: t = p/pow(p,x)
−
<span style="color: #ff4040;">sage:</span> t.simplify()
+
sage: t.simplify()
−
p^(-x + 1)</code></pre>
+
p^(-x + 1)</pre>
−
  <pre><code contenteditable style="margin-top: 20px;"><span style="color: #ff4040;">sage:</span> x = var('x')
+
<pre>sage: x = var('x')
−
<span style="color: #ff4040;">sage:</span> t = (x + 1)**3-x**3-1
+
sage: t = (x + 1)**3-x**3-1
−
<span style="color: #ff4040;">sage:</span> t.full_simplify()
+
sage: t.full_simplify()
−
3*x^2 + 3*x</code></pre>
+
3*x^2 + 3*x</pre>
  
−
  <h1>Egyenletek megoldása</h1>
+
<h1>Egyenletek megoldása</h1>
  
−
  <p><code>solve()</code> – megpróbálja szimbolikus átalakításokkal meghatározni az egyenlet gyökét</p>
+
<p><code>solve()</code> – megpróbálja szimbolikus átalakításokkal meghatározni az egyenlet gyökét</p>
−
  <pre><code contenteditable style="margin-top: 20px;"><span style="color: #ff4040;">sage:</span> (x + 1/x == 4).solve(x)
+
<pre>sage: (x + 1/x == 4).solve(x)
−
[x == -sqrt(3) + 2, x == sqrt(3) + 2]</code></pre>
+
[x == -sqrt(3) + 2, x == sqrt(3) + 2]</pre>
−
  <div class="fragment"><p><code>roots()</code> – mint a solve, csak az eredményt numerikusan és a gyök multiplicitását adja vissza</p>
+
<p><code>roots()</code> – mint a solve, csak az eredményt numerikusan és a gyök multiplicitását adja vissza</p>
−
    <pre><code contenteditable style="margin-top: 20px;"><span style="color: #ff4040;">sage:</span> (x**2 + 2*x + 1 == 0).roots(x)
+
<pre>sage: (x**2 + 2*x + 1 == 0).roots(x)
−
[(-1, 2)]</code></pre>
+
[(-1, 2)]</pre>
−
    <pre><code contenteditable style="margin-top: 20px;"><span style="color: #ff4040;">sage:</span> (x**3 - x**2 - x + 1 == 0).roots(x)
+
<pre>sage: (x**3 - x**2 - x + 1 == 0).roots(x)
−
[(-1, 1),(1, 2)]</code></pre></div>
+
[(-1, 1),(1, 2)]</pre>
  
−
  <p>Az előző metódusok néha nem tudnak explicit alakban megoldani egy egyenletet, vagy nem ad meg minden gyököt,
+
<p>Az előző metódusok néha nem tudnak explicit alakban megoldani egy egyenletet, vagy nem ad meg minden gyököt,
−
    vagy hamis gyököket talál. Ekkor a find_root() segíthet egy numerikus megoldást találni a megadott intervallumon
+
  vagy hamis gyököket talál. Ekkor a <code>find_root()</code> segíthet egy numerikus megoldást találni a megadott intervallumon
−
    <br/>(legyen pl: 0 < y < &pi;/2):</p>
+
  <br/>(legyen pl: 0 < y < &pi;/2):</p>
−
  <pre><code contenteditable style="margin-top: 20px;"><span style="color: #ff4040;">sage:</span> y = var(’y’)
+
<pre>sage: y = var(’y’)
−
<span style="color: #ff4040;">sage:</span> find_root(cos(y) == sin(y), 0, pi/2)
+
sage: find_root(cos(y) == sin(y), 0, pi/2)
−
0.78539816339744839</code></pre>
+
0.78539816339744839</pre>
−
  <p>Az algoritmus mindig csak egy gyököt talál meg és az is egy közelítő érték.</p>
+
<p>Az algoritmus mindig csak egy gyököt talál meg és az is egy közelítő érték.</p>

A lap jelenlegi, 2012. szeptember 20., 12:14-kori változata

Tartalomjegyzék

Beépített függvények

Összetett adattípusokon általánosan értelmezett függvények

tuplesetlistdict
új elem-addinsert,
append		(update)
elem törlése-removeremove(pop)
törlés mind-clear-clear
elem kivétele-poppoppop
elem indexeindex-index-
hányszor szerepelcount-count-
másolás-copy-copy

Reference

  • add(<item>)
– új elem hozzáadása
  • insert(<index>,<item>)
– új elem beillesztése
  • append(<item>)
– új elem hozzáfűzése
  • remove(<item>)
– elem törlése
  • clear()
– gyűjtemény kiürítése
  • S: pop()
    L: pop([<index>])
    D: pop(<key>[, dv])
– egy elem visszaadása és törlése a gyüjteményből
  • index(<item>[, start [, stop]])
– elem indexe, ha tartalmazza
  • count(<item>)
– megszámolja és visszatér, hogy hányszor tartalmazza a gyűjtemény az adott elemet
  • copy()
– gyűjtemény lemásolása
  • len(<coll>)
– gyűjtemény hossza

Halmazok függvényei

S = set([pi, 'abc', 35, pi])

  • union(<coll>[, <coll>]*)
    egyesíti a halmazokat, az eredménnyel visszatér
  • update(<coll>[, <coll>]*)
    union - az eredmény bekerül az "első" halmazba (|=)
  • intersection(<coll>[, <coll>]*),
    intersection_update(<coll>[, <coll>]*)
    visszaadja a közös részt ill. halmaz felülírása az eredménnyel (&, &=)
  • difference(<coll>[, <coll>]*),
    difference_update<coll>[, <coll>]*)
    különbség visszaadása ill. halmaz felülírása az eredménnyel (-, -=)
  • discard(<item>), remove(<item>)
    elem törlése a halmazból, remove esetén hiba, ha nem létezik
  • isdisjoint(coll)
    igaz, ha nincs közös elemük
  • issubset(<coll>)
    részhalmaza-e a paraméter (<, <=)
  • issuperset(<coll>)
    a halmaz részhalmaza-e a paraméternek (>, >=)

Lista függvényei

L = ['a', 'orange', 1, 1.56]

  • sort([cmp=None,] [key=None,] [reverse=False])
    rendezi a lista elemeit
  • extend(<coll>)
    hozzáadja a paraméterként átadott gyűjtemény elemeit a listához (+)
  • reverse()
    megfordítja a lista elemeinek sorrendjét
  • * operator
    lemásolja és összefűzi újra a lista elemeit

Szótár függvényei

D = {'a':4, 'orange':5, 1:5, 1.56:5.67}

  • get(<key>[, <dv>])
    a kulcshoz tartozó értékkel tér vissza, ha létezik;
    egyébként None ill. dv, ha megadtuk
  • has_key(<key>)
    igaz, ha a szótár eleme a kulcs
  • items()
    a szótár elemeit adja vissza egy listában (kulcs, érték) tuple formajában
  • keys()
    a kulcsokat adja vissza egy listában
  • iterkeys()
    szótár kulcsain lépkedő iterátorral tér vissza
  • iteritems()
    szótár értékein lépkedő iterátorral tér vissza
  • popitem()
    szótár egy elemét eltávolítja és visszaadja (kulcs, érték) tuple formájában
  • update(<coll>)
    dict vagy tuple lista elemeit illeszti be a szótárba
  • setdefault(<key>[, value])
    beilleszti az elemet és visszatér az értékkel
  • values()
    visszatér az értékekből képzett listával

Függvények számításokhoz

  • var(<string>)
    szimbolikus számításokhoz hozhatunk létre változókat
  • subs(<args>)
    kifejezés függvénye, amivel behelyettesíthetjük a változókat a paraméterben felsorolt értékekkel és visszakapjuk a kifejezés numerikus eredményét
  • float(<kif|num|string>)
    lebegőpontos számmá próbálja alakítani a megadott paramétert (lsd. RR, RDF)
  • n()
    kifejezések függvénye, a kiértékelt kifejezést adja vissza
  • exp(3)
    e3
  • pow(x,z)
    xz
  • log(exp(3)) – természetes alapú log
    3
  • sqrt(16) – négyzetgyök
    4
  • sin(pi), cos(pi), tan(pi) – szögfüggvények
    arcsin(), ... – inverzeik
  • floor(4.5) – alsó egészrész
    4
  • ceil(4.6) – felső egészrész
    5

Egyenlőség vizsgálata lebegőpontos számok esetén

Fontos megjegyezni, hogy a lebegőpontos számok mindig közelítő értékek, így két lebegőpontos szám, ami pl. számítás eredménye, valószínűleg nem egyezik meg egymással!

sage: sqrt(4.0)^2 == 4.0
True

DE

sage: sqrt(5.0)^2 == 5.0
False

Megoldás:

sage: abs(sqrt(5.0)^2 == 5.0) < 10^(-10)
True

Kifejezeséken használt függvények

Az algebrai kifejezeséket összeggé alakíthatjuk az expand() függvénnyel vagy .expand() metódussal, ill. szorzattá a .factor()-ral:

sage: a,b = var('a','b')
sage: expand((a+b)^2)
a^2+2*a*b+b^2
sage: x = var('x')
sage: (x^2-1).factor()
(x-1)*(x+1)

A kifejezéseket a simplify() vagy a full_simplify() metódussal tudjuk egyszerűsíteni:

sage: p,x = var('p','x')
sage: t = p/pow(p,x)
sage: t.simplify()
p^(-x + 1)
sage: x = var('x')
sage: t = (x + 1)**3-x**3-1
sage: t.full_simplify()
3*x^2 + 3*x

Egyenletek megoldása

solve() – megpróbálja szimbolikus átalakításokkal meghatározni az egyenlet gyökét

sage: (x + 1/x == 4).solve(x)
[x == -sqrt(3) + 2, x == sqrt(3) + 2]

roots() – mint a solve, csak az eredményt numerikusan és a gyök multiplicitását adja vissza

sage: (x**2 + 2*x + 1 == 0).roots(x)
[(-1, 2)]
sage: (x**3 - x**2 - x + 1 == 0).roots(x)
[(-1, 1),(1, 2)]

Az előző metódusok néha nem tudnak explicit alakban megoldani egy egyenletet, vagy nem ad meg minden gyököt, vagy hamis gyököket talál. Ekkor a find_root() segíthet egy numerikus megoldást találni a megadott intervallumon
(legyen pl: 0 < y < π/2):

sage: y = var(’y’)
sage: find_root(cos(y) == sin(y), 0, pi/2)
0.78539816339744839

Az algoritmus mindig csak egy gyököt talál meg és az is egy közelítő érték.

A lap eredeti címe: „http://wiki.math.bme.hu/index.php?title=Informatika1-2012/Eloadas3&oldid=7734”
Személyes eszközök