...

3.14 * 7.5**2

176.625

import math

math.sqrt( 176.6 / math.pi )

7.497567999028581

from math import sqrt, pi
sqrt( 176.6 / pi )

7.497567999028581

from math import *

pindala = 176.6
raadius = sqrt( pindala / pi )
raadius

7.497567999028581

from math import sin, pi

deg = ...
sin(30*deg)

from scipy.constants import m_e, h, eV, e, epsilon_0 as eps
m_e * e**4 / (8 * h**2 * eps**2) / eV

13.605693122885842

print(pindala)
print(raadius)

176.6
7.497567999028581

print( 'ringi raadius on', raadius, 'ning pindala', pindala )

ringi raadius on 7.497567999028581 ning pindala 176.6

print( 'ringi raadius on %.3f ning pindala %.1f' % (raadius, pindala) )

ringi raadius on 7.498 ning pindala 176.6

print( f'ringi raadius on {raadius:.3f} ning pindala {pindala:.1f}' )

ringi raadius on 7.498 ning pindala 176.6

print('%.4f' % raadius)
print('%.4e' % raadius)
print('%.4g' % raadius)

7.4976
7.4976e+00
7.498

x = 2.641e8
print('%.4f' % x)
print('%.4e' % x)
print('%.4g' % x)

264100000.0000
2.6410e+08
2.641e+08

from math import sin, cos
from scipy.constants import degree as deg, g

# algandmed
kiirus = 62 # algkiirus [m/s]
nurk = 45 # viskenurk kraadides

# arvutus
nurk = nurk * deg # radiaanideks
kiirus_x = kiirus * cos(nurk)
kiirus_y = kiirus * sin(nurk)
aeg = 2 * kiirus_y / g # lennuaeg
kaugus = kiirus_x * aeg
print(f'lennukaugus = {kaugus:.1f} m')

lennukaugus = 392.0 m

from IPython.display import display, Markdown
from math import floor, log10

x = 1.38e-23
astendaja = floor(log10(x))
mantiss = x / 10**astendaja
md = '**Boltzmanni konstandi** väärtus on %.2f &times; 10<sup>%d</sup> J K<sup>-1</sup>'
md = md % (mantiss, astendaja)
md = md.replace('-', '&minus;').replace('.', ',')
display(Markdown(md))

from IPython.display import Latex

display(
    Latex('$\vec F = m\vec a$'),
    Latex('$\\vec F = m\\vec a$'),
    Latex(r'$\vec F = m\vec a$')
)

x = 62
type(x)

int

jagatav = 62
jagaja = 11

jagatis = jagatav // jagaja
jääk = jagatav % jagaja
print(f'{jagatav} / {jagaja} = {jagatis} (jääk {jääk})')

# taastame algse arvu jagatise ja jäägi kaudu
algne = jagatis * jagaja + jääk
print(f'{jagatis} * {jagaja} + {jääk} = {algne}')

62 / 11 = 5 (jääk 7)
5 * 11 + 7 = 62

from math import factorial
factorial(500)

1220136825991110068701238785423046926253574342803192842192413588385845373153881997605496447502203281863013616477148203584163378722078177200480785205159329285477907571939330603772960859086270429174547882424912726344305670173270769461062802310452644218878789465754777149863494367781037644274033827365397471386477878495438489595537537990423241061271326984327745715546309977202781014561081188373709531016356324432987029563896628911658974769572087926928871281780070265174507768410719624390394322536422605234945850129918571501248706961568141625359056693423813008856249246891564126775654481886506593847951775360894005745238940335798476363944905313062323749066445048824665075946735862074637925184200459369692981022263971952597190945217823331756934581508552332820762820023402626907898342451712006207714640979456116127629145951237229913340169552363850942885592018727433795173014586357570828355780158735432768888680120399882384702151467605445407663535984174430480128938313896881639487469658817504506926365338175055478128640000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

x = 3.14
type(x)

float

0.1 + 0.2 - 0.3

5.551115123125783e-17

(9+8j) / (5-2j)

(1+2j)

from cmath import sqrt, exp

x = exp(3-2j)*sqrt(-4+1j)
print(f'{x:.3f}')

34.734-21.376j

from math import sqrt

# ruutvõrrandi kordajad
a, b, c = 3, 7, -12

if a == 0:
    if b != 0:
        print( f'x = {-c / b :.3f}' )
    elif c != 0:
        print( 'Võrrandil puuduvad lahendid!' )
    else:
        print( 'Võrrand on rahuldatud iga x korral!' )
else:
    D = b**2 - 4 * a * c  # diskriminant
    if D > 0:
        D = sqrt(D)
        print( f'x1 = {(-b + D) / (2 * a) :.3f}, x2 = {(-b - D) / (2 * a) :.3f}' )
    elif D == 0:
        print( f'x = {-b / (2 * a) :.3f}' )
    else:
        print( 'Võrrandil puuduvad reaalarvulised lahendid!' )

x1 = 1.149, x2 = -3.482

n = 10

k, fact = n, 1
while k > 1:
    fact *= k
    k -= 1

print( f'arvu {n} faktoriaal on {fact}' )

arvu 10 faktoriaal on 3628800

algsumma = 1000
säästud = 500
intress = 0.03
aastaid = 7

periood = 0 # mitu perioodi oleme juba läbi käinud
konto = algsumma
while periood < aastaid:
    konto = konto + intress * konto + säästud
    print( f'{periood + 1}. aasta lõpuks on kogunenud {konto:.2f} EUR' )
    periood += 1

1. aasta lõpuks on kogunenud 1530.00 EUR
2. aasta lõpuks on kogunenud 2075.90 EUR
3. aasta lõpuks on kogunenud 2638.18 EUR
4. aasta lõpuks on kogunenud 3217.32 EUR
5. aasta lõpuks on kogunenud 3813.84 EUR
6. aasta lõpuks on kogunenud 4428.26 EUR
7. aasta lõpuks on kogunenud 5061.10 EUR

from math import exp

f = lambda x: exp(-x) - x
a, b, eps = 0.1, 1.0, 0.0002

while abs(a - b) > eps:
    c = (a + b) / 2
    print( f'{c:.5f}' )
    if f(a) * f(c) < 0:
        b = c
    else:
        a = c

0.55000
0.77500
0.66250
0.60625
0.57812
0.56406
0.57109
0.56758
0.56582
0.56670
0.56714
0.56736
0.56725

print('   °C    °F')
for C in range(0, 101, 10):
    print( f'{C:5d} {9 * C // 5 + 32:5d}' )

   °C    °F
    0    32
   10    50
   20    68
   30    86
   40   104
   50   122
   60   140
   70   158
   80   176
   90   194
  100   212

for x in range(1,11):
    for y in range(1,11):
        print( f'{x * y:5d}', end='')
    print() # reavahetus

    1    2    3    4    5    6    7    8    9   10
    2    4    6    8   10   12   14   16   18   20
    3    6    9   12   15   18   21   24   27   30
    4    8   12   16   20   24   28   32   36   40
    5   10   15   20   25   30   35   40   45   50
    6   12   18   24   30   36   42   48   54   60
    7   14   21   28   35   42   49   56   63   70
    8   16   24   32   40   48   56   64   72   80
    9   18   27   36   45   54   63   72   81   90
   10   20   30   40   50   60   70   80   90  100

import math, cmath

def leia_ruutlahend(a, b, c):
    D = b**2 - 4 * a * c
    D = math.sqrt(D) if D >= 0 else cmath.sqrt(D)  # lühivariant tingimuslausest
    return (-b + D) / (2 * a), (-b - D) / (2 * a)

def kuva_ruutlahend(a, b, c):
    x1, x2 = leia_ruutlahend(a, b, c)
    print( f'kordajad: a={a}, b={b}, c={c}' )
    print( f'lahendid: {x1:.3f}, {x2:.3f}' )
    print()

kuva_ruutlahend(2, 3, -14)
kuva_ruutlahend(5, 6, 2)

kordajad: a=2, b=3, c=-14
lahendid: 2.000, -3.500

kordajad: a=5, b=6, c=2
lahendid: -0.600+0.200j, -0.600-0.200j

from math import *

def tuletis(f, järk=1, kohal=0.0, samm=1e-8):
    if järk == 1:
        return (f(kohal + samm) - f(kohal - samm)) / (2 * samm)
    
    if järk == 2:
        return (f(kohal + samm) - 2 * f(kohal) + f(kohal - samm)) / samm**2
    
    raise NotImplementedError('Sellist järku tuletise algoritm ei ole realiseeritud')

print( tuletis(exp) )
print( tuletis(exp, samm=1e-5) )
print( tuletis(sin, järk=2, kohal=pi/2, samm=1e-4) )
print( tuletis(lambda x: sin(x)*cos(x)) )

0.9999999994736442
1.0000000000121023
-0.999999993922529
1.0

voldid = [0.50, 1.00, 1.50, 2.00, 2.50, 3.00, 3.50, 4.00]
milliamprid = [41, 83, 125, 166, 207, 248, 291, 332]

amprid = []
for vool in milliamprid:
    amprid.append(0.001 * vool)

print(amprid)

[0.041, 0.083, 0.125, 0.166, 0.20700000000000002, 0.248, 0.291, 0.332]

amprid = [0.001 * vool for vool in milliamprid]
print(amprid)

[0.041, 0.083, 0.125, 0.166, 0.20700000000000002, 0.248, 0.291, 0.332]

lugeja, nimetaja = 0, 0
for i in range(len(voldid)):
    lugeja += voldid[i] * voldid[i]
    nimetaja += voldid[i] * amprid[i]

print(f'lugeja = {lugeja:.2f}, nimetaja = {nimetaja:.3f}')

lugeja = 51.00, nimetaja = 4.231

lugeja, nimetaja = 0, 0
for pinge, vool in zip(voldid, amprid):
    lugeja += pinge * pinge
    nimetaja += pinge * vool    

print(f'lugeja = {lugeja:.2f}, nimetaja = {nimetaja:.3f}')

lugeja = 51.00, nimetaja = 4.231

from pprint import pprint #pretty print
pprint( list(zip(voldid, amprid)) )

[(0.5, 0.041),
 (1.0, 0.083),
 (1.5, 0.125),
 (2.0, 0.166),
 (2.5, 0.20700000000000002),
 (3.0, 0.248),
 (3.5, 0.291),
 (4.0, 0.332)]

lugeja = sum(pinge * pinge for pinge in voldid)
nimetaja = sum(pinge * vool for pinge, vool in zip(voldid, amprid))
print(f'lugeja = {lugeja:.2f}, nimetaja = {nimetaja:.3f}')

lugeja = 51.00, nimetaja = 4.231

andmed = ((0.5, 41),
          (1.0, 83),
          (1.5, 125),
          (2.0, 166),
          (2.5, 207),
          (3.0, 248),
          (3.5, 291),
          (4.0, 332))

lugeja = sum(pinge * pinge for pinge, vool in andmed)
nimetaja = sum(0.001 * pinge * vool for pinge, vool in andmed)
print(f'lugeja = {lugeja:.2f}, nimetaja = {nimetaja:.3f}')

lugeja = 51.00, nimetaja = 4.231

takistus = lugeja / nimetaja
print( f'takistus = {takistus:.3f} Ω' )

takistus = 12.054 Ω

x = 1, 2, 3
type(x)

tuple

a, (b, c) = [1, (2, 3)]
print(f'a = {a}, b = {b}, c = {c}')

a = 1, b = 2, c = 3

a, b, c = 1, 2, 3

a, b = b, a
print('a =', a)
print('b =', b)

a = 2
b = 1

def keskmine(*arvud):
    if len(arvud) == 0:
        raise RuntimeError('Funktsioon vajab vähemalt ühe argumendi!')
    return sum(arvud) / len(arvud)

keskmine(2, 4, 8, 3, 5)

4.4

def summa(*objektid):
    if len(objektid) == 0:
        raise RuntimeError('Funktsioon vajab vähemalt ühe argumendi!')
    tulemus = 0.
    for x in objektid:
        if isinstance(x, (int, float)):
            tulemus += x
        elif isinstance(x, (tuple, list)):
            tulemus += summa(*x)
        else:
            raise TypeError('Argumendi tüüp on tundmatu!')
    return tulemus

summa(2, 4, (8, 6), 3, [5, 9, (7, 1)])

45.0

from matplotlib.pyplot import *
from math import sin, cos, pi

n = 200 # mitu andmepunkti
X = [4 * pi * i / n for i in range(n)] # vahemikus 0...4pi
Y1 = [sin(x) for x in X]
Y2 = [cos(x) for x in X]

figure(figsize=(6,3), dpi=120)
plot(X, Y1, 'r-', label='sin(x)')
plot(X, Y2, 'b--', label='cos(x)')
xlim(0, 4*pi)
title('harmooniline võnkumine')
xlabel('aeg')
ylabel('signaal')
legend(loc='lower left')
grid(color='gray', linestyle=':')
show()

figure(figsize=(4,4), dpi=120)
n = 300
θ = [2 * pi * i / n for i in range(n)]
R = [2 - sin(6*t) - 0.5 * cos(30*t) for t in θ]
polar(θ, R, 'b-')
ylim(0, 3.5)
show()

from math import exp

# "eksperimentaalsed" andmepunktid
X1 = [1, 2, 3, 4, 5]
Y1 = [2.5, 8, 20, 56, 173]

# teoreetiline sõltvus (pidevjoon) peenema sammuga
X2 = [0.1*i for i in range(55)]
Y2 = [exp(x) for x in X2]

figure(figsize=(7,3), dpi=120)
subplot(121)
plot(X1, Y1, "bo", label="katse")
plot(X2, Y2, "r-", label="teooria")
grid()
legend()
subplot(122)
plot(X1, Y1, "bo")
plot(X2, Y2, "r-")
yscale('log')
grid()
show()

figure(figsize=(7,3), dpi=120)
subplot(121)
plot(X1, Y1, 'bo')
plot(X2, Y2, 'r-')
xticks( tuple(range(6)) )
grid()

subplot(122)
plot(X1, Y1, 'bo')
plot(X2, Y2, 'r-')
yscale('log')
xticks( tuple(range(6)) )
asukohad = 1, 3, 10, 30, 100
yticks( asukohad, asukohad )  # kriipsud ja nende tähised
grid()
show()

import numpy as np

voldid = np.array( (0.50, 1.00, 1.50, 2.00, 2.50, 3.00, 3.50, 4.00) )
amprid = np.array( (0.041, 0.083, 0.125, 0.166, 0.207, 0.248, 0.291, 0.332) )

voldid / amprid

array([12.19512195, 12.04819277, 12.        , 12.04819277, 12.07729469,
       12.09677419, 12.02749141, 12.04819277])

takistus = np.sum(voldid**2) / voldid.dot(amprid)  # või np.sum(voldid**2) / np.sum(voldid*amprid)
print( f'takistus = {takistus:.3f} Ω' )

takistus = 12.054 Ω

from matplotlib.pyplot import *
from numpy import sin, cos, pi, linspace

x = linspace(0, 4*pi, 200)  # 0 kuni 4*pi, 200 punkti

figure(figsize=(6,3), dpi=120)
plot(x, sin(x), 'r-')
plot(x, cos(x), 'b--')
xlim(0, 4*pi)
xlabel('aeg')
ylabel('signaal')
grid()
show()

from numpy import exp, geomspace
from scipy.constants import micro, c, h, k

# λ on lainepikkus või lainepikkuste vektor [µm], T on temperatuur [K]
def planck(λ, T):
    λ = λ * micro
    a = exp(h * c / (λ * k * T)) - 1  # abimuutuja
    return 2 * pi * h * c**2 / λ**5 / a * micro

x = geomspace(0.1, 100, 200) # 0.1 kuni 100 µm, 200 punkti

figure(figsize=(6,4), dpi=120)
for temp, värv in zip( (400, 1000, 3000), ('b', 'g', 'r') ):
    plot(x, planck(x, temp), '-', color=värv, label=f'T={temp:.0f} K')

xlabel('lainepikkus (µm)')
ylabel('kiirguse intensiivsus\nW m$^{-2}$ µm$^{-1}$')
ylim(ymin=1)
xscale('log')
yscale('log')
legend()
grid()
show()

andmed = np.array( (0.50, 41, 1.00, 83, 1.50, 125, 2.00, 166,
                    2.50, 207, 3.00, 248, 3.50, 291, 4.00, 332) )

andmed = andmed.reshape(-1, 2)
print( andmed )

[[   0.5   41. ]
 [   1.    83. ]
 [   1.5  125. ]
 [   2.   166. ]
 [   2.5  207. ]
 [   3.   248. ]
 [   3.5  291. ]
 [   4.   332. ]]

from numpy import linspace, polyfit
from numpy.random import randn, seed
seed(42)

n = 20
X = linspace(0, 5, n)
Y = 3 * X + 7 + 2 * randn(n)
a, b = polyfit(X, Y, 1)
Y1 = a * X + b
figure(figsize=(6,4), dpi=120)
plot(X, Y, 'bo')
plot(X, Y1, 'r-')
text(0, 20, f'$y={a:.3f}x+{b:.3f}$', backgroundcolor='white')
grid()
show()

from numpy import exp, linspace
from scipy.optimize import brentq
from matplotlib.pyplot import *

f = lambda x: exp(-x) - x
nullkoht, info = brentq(f, 0.1, 1.0, xtol=1e-10, full_output=True)
print( f'nullkoht = {nullkoht:.10f}' )
print( f'funktsiooni väljakutseid: {info.function_calls}' )

x = linspace(0.4, 0.75, 100)
figure(figsize=(3,3), dpi=120)
plot(x, f(x), 'b-')
plot(nullkoht, 0, 'ro')
grid()
show()

nullkoht = 0.5671432904
funktsiooni väljakutseid: 7

tabel = []
f = open('spekter.txt', 'r')
for rida in f:
    sõnad = rida.split()
    arvud = tuple( float(s) for s in sõnad )
    tabel.append( arvud )
f.close()

print(f'failist loeti {len(tabel)} rida')
for rida in tabel[:5]:
    print( '%7.2f %10.6f' % rida )

failist loeti 4592 rida
 380.66   0.000020
 380.73   0.000013
 380.79   0.000009
 380.86   0.000006
 380.92   0.000004

import sys

tabel = []
with open('spekter2.txt', 'r') as f:
    for rida in f:
        sõnad = rida.split()
        try:
            arvud = tuple( float(s) for s in sõnad )
        except:
            sys.stderr.write( 'Vigases formaadis rida: ' + rida )
            continue
        tabel.append(arvud)

print(f'failist loeti {len(tabel)} rida')
for rida in tabel[:5]:
    print( '%7.2f %10.6f' % rida )

failist loeti 4592 rida
 380.66   0.000020
 380.73   0.000013
 380.79   0.000009
 380.86   0.000006
 380.92   0.000004

Vigases formaadis rida: andmed algavad siit
Vigases formaadis rida: faili l6pp

andmed =   ((0.5, 41),
            (1.0, 83),
            (1.5, 125),
            (2.0, 166),
            (2.5, 207),
            (3.0, 248),
            (3.5, 291),
            (4.0, 332))

with open('andmed.txt', 'w', encoding='utf8') as f:
    f.write( '%10s%10s%14s\n' % ('pinge (V)', 'vool (A)', 'takistus (Ω)') )
    for rida in andmed:
        pinge, vool = rida
        vool *= 1e-3
        takistus = pinge / vool
        f.write( f'{pinge:10.2f}{vool:10.3f}{takistus:14.2f}\n' )

import numpy as np

tabel = np.loadtxt('spekter.txt')
ridu, veerge = tabel.shape
print(f'failist loeti {ridu} rida')
print( tabel[:5] )

failist loeti 4592 rida
[[3.8066e+02 1.9606e-05]
 [3.8073e+02 1.2948e-05]
 [3.8079e+02 8.8751e-06]
 [3.8086e+02 6.2632e-06]
 [3.8092e+02 4.4803e-06]]

from matplotlib.pyplot import *

X, Y = tabel.transpose()

figure(figsize=(7,3), dpi=120)
plot(X, Y, 'b-')
xlabel('lainepikkus')
ylabel('signaal')
grid()
show()

import pandas as pd

tabel = pd.read_table('andmed.txt')
tabel.index += 1  # muidu algavad reanumbrid 0-st
tabel

tabel = pd.read_table('andmed.txt', skiprows=1, names=('x', 'y'))
tabel.index += 1
tabel

from sympy import *
v,g = symbols('v,g')  # näiteks algkiirus ja raskuskiirendus
type(v)

sympy.core.symbol.Symbol

t = v / g
h = v * t - Rational(1,2) * g * t**2
h

v**2/(2*g)

srepr(h)

"Mul(Rational(1, 2), Pow(Symbol('g'), Integer(-1)), Pow(Symbol('v'), Integer(2)))"

init_printing()
h

var('a,b')
expand( (a + b)**2 )

factor(_)

cancel((a**2-b**2)/(a+b))

expand_trig( sin(a + b) )

trigsimp(_)

( (a + b)**2 ).expand()

var('x')
( (a + b)**2 ).subs(a,x).subs(b,1).expand()

var('a,b')
log(a*b).expand()

var('a,b')
log(a*b).expand(force=True)

var('a,b', positive=True)
log(a*b).expand()

var('a,b', positive=True)
logcombine(log(a)-log(b))

var('n', real=True)
logcombine(n*log(a))

var('alpha', real=True)
exp(I*alpha).expand(complex=True)

var('alpha')
exp(I*alpha).expand(complex=True)

E**(I * pi) + 1

from IPython.display import display

display( sqrt(17), sqrt(-8), sin(pi/7), sin(pi/3) )

print( N(sin(pi/7)) )
print( sin(pi/7).evalf(60) )

0.433883739117558
0.433883739117558120475768332848358754609990727787459876444547

tan(pi/2)

import math
math.tan(math.pi/2)

import math
x = 1.3e-8
(math.sqrt(1 + 2*x**2) - 1)/x

1.7080354225002406e-08

x = Float('1.3e-8', 30)
(sqrt(1 + 2*x**2) - 1)/x

var('x')
limit(sin(x)/x, x, 0)

var('n')
limit((1+1/n)**n, n, oo)

var('x')
series(ln(1 + x), x, 0, 2)

var('n')
series((1 + x)**n, x, 0, 2)

series(cos(x), x, 0, 3)

var('x,y,n')
diff(x**n, x)

simplify(_)

sqrt(x**2 + y**2).diff(x, y)

var('x')
integrate(1 / x, x)

integrate(sqrt(1 - x**2), (x, -1, 1))

display( integrate(exp(-x**2), x) )
display( diff(erf(x), x) )

var('C') # integreerimiskonstant
a = Integral(exp(-x**2), x)
b = Derivative(erf(x), x)
display( Eq(a, a.doit() + C) )
display( Eq(b, b.doit() + C) )

var('n')
summation(2**-n, (n, 1, oo))

var('n,q')
S = Sum(q**n, (n, 0, oo))
Eq(S, S.doit())

var('a,b,c,x')
solve(a * x**2 + b * x + c, x)

x = Function('x') # koordinaat (ajast sõltuv)
t = Symbol('t')   # aeg (sõltumatu muutuja)
w = Symbol('omega', positive=True)
lahend = dsolve(x(t).diff(t,2) + w**2 * x(t), x(t))
lahend

var('A,C1,C2')
avaldis = lahend.rhs
konst = solve( (avaldis.subs(t,0) - A, avaldis.diff(t).subs(t,0)), (C1,C2) )
konst

lahend.subs(konst)

from IPython.display import Math

# abifunktsioon, mida läheb siin ja edaspidi vaja
def kuva(sumbol, objekt):
    display(Math(sumbol + '=' + latex(objekt)))

var('a:d')
A = Matrix([[a, b], [c, d]])
B = Matrix(2, 3, lambda i, j: 3*i+j+1)

kuva('A', A)
kuva('B', B)

B = zeros(2, 3)
for i in range(0,2):
    for j in range(0,3):
        B[i,j] = 3*i+j+1

kuva('B', B)

C = B * B.T
kuva('|A|', A.det())
kuva('C=B\cdot B^T', C)
kuva('C^{-1}', C.inv())
kuva('C\cdot C^{-1}', C*C.inv())

var('a1,a2,a3,b1,b2,b3')
a = Matrix([a1,a2,a3])
b = Matrix([b1,b2,b3])
kuva(r'a\cdot b', a.dot(b))
kuva(r'a\times b', a.cross(b))
kuva('|a|', a.norm())

%%html
<style>
div.harjutus { background-color: Khaki; padding: 1ex; }
code { background-color: transparent !important;
      padding: 0px 0.3ex !important; }
table.cmdlist { width: 100%; }
table.center th, table.center td { text-align: center; }
table.left th, table.left td { text-align: left; }
kbd { color: black; background-color: #E0E2EB; border: solid #000000 1px;
    display: inline-block; text-align: center; min-width: 0.9em;
    font-family: "Courier New", Courier, monospace;
    font-size: 90%; font-weight: bold; padding: 0px 2px;
    border-radius: 0.2em; white-space: pre; }
.cm-s-ipython.CodeMirror { background: WhiteSmoke; }
div.untrusted { display: none; }
</style>

Kood	Tulemus
`\vec F = m\vec a`	$$\vec F = m\vec a$$
`x = \frac{-b\pm\sqrt{b^2 - 4ac}}{2a}`	$$x = \frac{-b\pm\sqrt{b^2 - 4ac}}{2a}$$
`\sin\left(\alpha+\frac{\pi}{2}\right)=\cos\alpha`	$$\sin\left(\alpha+\frac{\pi}{2}\right)=\cos\alpha$$
`\ln(n!)\approx n\ln n-n`	$$\ln(n!)\approx n\ln n-n$$
`e^x = \sum_{n=0}^\infty \frac{x^n}{n!}`	$$e^x=\sum_{n=0}^\infty\frac{x^n}{n!}$$

Python ja Jupyter Notebook¶

Sisukord

Algteadmised¶

Toimetamine Jupyteri töölehel¶

Lihtsaimad arvutused¶

Sõne¶

Kommentaarid¶

Tekst, joonised ja valemid¶

Markdown¶

LaTeX¶

Andmetüübid¶

Täisarvud¶

Ujukomaarvud¶

Kompleksarvud¶

Programmeerimine¶

IF-lause¶

WHILE-tsükkel¶

FOR-tsükkel¶

Alamprogramm¶

Jadad¶

Graafikud¶

NumPy¶

Numbrilised algoritmid¶

Failide lugemine-kirjutamine¶

Sümbolarvutus¶

Sümbolid ja avaldised¶

Avaldiste teisendamine¶

Matemaatiline analüüs¶

Võrrandite lahendamine¶

Lineaaralgebra¶

pinge (V)	vool (mA)
0,50	41
1,00	83
1,50	125
2,00	166
2,50	207
3,00	248
3,50	291
4,00	332

	pinge (V)	vool (mA)
1	0.5	41
2	1.0	83
3	1.5	125
4	2.0	166
5	2.5	207
6	3.0	248
7	3.5	291
8	4.0	332

	x	y
1	0.5	41
2	1.0	83
3	1.5	125
4	2.0	166
5	2.5	207
6	3.0	248
7	3.5	291
8	4.0	332