Ogled vira Python (programski jezik)

{{infopolje Programski jezik
 | name                   = Python
 | logo                   = [[Slika:Python logo and wordmark.svg|250px]]
 | logo caption           = Logotip
 | screenshot             = 
 | screenshot caption     = 
 | file ext               = <!-- wikipodatki -->
 | paradigm               = 
 | released               = <!-- {{Start date|YYYY}} -->
 | designer               = <!-- wikipodatki -->
 | developer              = <!-- wikipodatki -->
 | latest release version = <!-- wikipodatki -->
 | latest release date    = 
 | typing                 = dinamično, močno, varno
 | implementations        = '''[[CPython]]''', [[IronPython]], [[Jython]], [[Python for S60]], [[PyPy]]
 | dialects               = 
 | influenced by          = <!-- wikipodatki -->
 | influenced             = [[Programski jezik Boo|Boo]], [[Programski jezik Cobra|Cobra]], [[Programski jezik D|D]], [[Programski jezik Falcon|Falcon]], [[Programski jezik Groovy|Groovy]], [[JavaScript]], [[Programski jezik Ruby |Ruby]]
 | programming language   = 
 | platform               = 
 | operating system       = <!-- wikipodatki -->
 | license                = <!-- wikipodatki -->
 | website                = <!-- wikipodatki -->
 | wikibooks              = Python Programming
}}
'''Python''' je [[interpreter|interpretni]] visokoravni večnamenski [[programski jezik]], ki ga je ustvaril [[Guido van Rossum]] leta [[1990 v znanosti|1990]]. Jezik je dobil ime po priljubljeni angleški [[televizijska nanizanka|televizijski nanizanki]] ''[[Leteči cirkus Montyja Pythona]]'' (''Monthy Python's Flying Circus''). Python podpira dinamične [[podatkovni tip|podatkovne tipe]], kar ga naredi drugačnega od npr. [[Java (programski jezik)|Jave]] ali družine [[Programski jezik C|C]]. Zaradi dinamičnih podatkovnih tipov je podoben jezikom [[Perl]], [[programski jezik Ruby|Ruby]], [[Scheme (programski jezik)|Scheme]], [[Smalltalk]] in [[Tcl]]. Upravlja s [[pomnilnik]]om in podpira funkcionalen, imperativen oziroma proceduralen, strukturiran in objektno orientiran programski stil. Razvili so ga kot [[Odprta koda|odprtokodni]] projekt, ki ga upravlja neprofitna organizacija Python Software Foundation.

== Pogosto uporabljene knjižnice ==
Python ima že ob namestitvi nekaj ''knjižnic'' oz. modulov. To so skupki programske kode, najpogosteje funkcij, ki jih nato pisci kode uporabijo v svojih programih. Nekaj izmed teh je napisanih v jeziku C<ref>{{Navedi splet|title=The Python Standard Library — Python 3.8.5 documentation|url=https://docs.python.org/3/library/|website=docs.python.org|accessdate=2020-08-22}}</ref> za doseganje optimalnih časov pri klicanju in izvedbi funkcij. Navkljub dejstvu, da je Python večplatformski, standardni nabor knjižnic ni enak na Linuxu<ref>{{Navedi splet|title=Unix Specific Services — Python 3.8.5 documentation|url=https://docs.python.org/3/library/unix.html|website=docs.python.org|accessdate=2020-08-22}}</ref> ali Windowsu<ref>{{Navedi splet|title=winsound — Sound-playing interface for Windows — Python 3.8.5 documentation|url=https://docs.python.org/3/library/winsound.html?highlight=winsound|website=docs.python.org|accessdate=2020-08-22}}</ref>. Primarne knjinžnice standardnega nabora so ''math''<ref>{{Navedi splet|title=math — Mathematical functions — Python 3.9.0 documentation|url=https://docs.python.org/3/library/math.html|website=docs.python.org|accessdate=2020-11-01}}</ref> ''–'' podpora matematičnih funkcij, ''sys''<ref name="#1">{{Navedi splet|title=sys — System-specific parameters and functions — Python 3.9.0 documentation|url=https://docs.python.org/3/library/sys.html?highlight=sys#module-sys|website=docs.python.org|accessdate=2020-11-01}}</ref> – za uporabo sistemskih funkcij in ''os''<ref>{{Navedi splet|title=os — Miscellaneous operating system interfaces — Python 3.9.0 documentation|url=https://docs.python.org/3/library/os.html?highlight=os#module-os|website=docs.python.org|accessdate=2020-11-01}}</ref> – za nadziranje funkcij operacijskega sistema.
{| class="wikitable"
|+Knjižnice standardnega nabora
!Ime knjižnice
!Namembnost
!Funkcije
|-
|math
|Podpora matematičnih funkcij v Pythonu
|pi, e, ceil, cos, sin, tan, log, degrees, radians
|-
|random<ref>{{Navedi splet|title=random — Generate pseudo-random numbers — Python 3.8.6 documentation|url=https://docs.python.org/3.8/library/random.html|website=docs.python.org|accessdate=2020-11-01}}</ref>
|Generacija naključnih števil in znakov
|random, randint, randrange, choice
|-
|datetime<ref>{{Navedi splet|title=datetime — Basic date and time types — Python 3.8.6 documentation|url=https://docs.python.org/3.8/library/datetime.html?highlight=datetime#module-datetime|website=docs.python.org|accessdate=2020-11-01}}</ref>
|Implementacija časovnih pasov 
|datetime, date, timeifo
|-
|tkinter<ref>{{Navedi splet|title=tkinter — Python interface to Tcl/Tk — Python 3.8.6 documentation|url=https://docs.python.org/3.8/library/tkinter.html?highlight=tkinter#module-tkinter|website=docs.python.org|accessdate=2020-11-01}}</ref>
|Dodana funkcionalnost grafičnih vmesnikov
|Tk, Label, Frame, Button, Entry
|-
|sys<ref name="#1"/>
|Vsebuje interpretno odvisne funkcije
|version, platform, path, argv 
|-
|os<ref>{{Navedi splet|title=os — Miscellaneous operating system interfaces — Python 3.9.0 documentation|url=https://docs.python.org/3/library/os.html|website=docs.python.org|accessdate=2020-11-01}}</ref>
|Služi kot vezni člen med Pythonovim večplatformskim delovanjem in operacijskim sistemom
|getcwd, popen, close, rename, 
|-
|json
|Delo z [[JSON]] podatki
|load, loads, dump, dumps
|}
Python je zaradi svoje preproste sintakse izredno preprost za uporabo. To omogoča programiranje tudi začetnikom. Je tudi odlika, ki veliko doprinese pri oblikovanju lastnih knjižnic. Knjižnice, ki niso v standardnemu naboru, so knjižnice t.i. 3. nabora. Naložene so na portalu [[PyPi]] in jih uporabnik sam namesti. Med njimi najdemo veliko knjižnic za velik asortiment področij. Trenutno je na portalu več kot 570.000 projektov z več kot 6.000.000 verzijami. 
{| class="wikitable"
|+Knjižnice 3. nabora
!Ime knjižnice
!Namembnost
|-
|pygame
|Temelji na SDL-ju in služi kot funkcionalni nabor za razvijanje iger
|-
|pandas
|Močno optimizirana knjižnica za ekstrahacijo in obdelavo podatkov 
|-
|matplotlib
|Knjižnica, namenjena prikazovanju grafov v obeh dimenzijah
|-
|numpy
|Knjižnica je namenjena numeričnim komputacijam in obdelavi tenzorjev
|-
|scipy
|Efektivna zbirka funkcij za komputacije v statistiki in algebri
|-
|requests
|Omogoča enostavno pošiljanje [[HTTP]] zahtevkov
|}

== Uporaba in namembnost Pythona v aplikacijah ==
Python uporablja različna orodja za različne tipe aplikacij, saj vsebuje tako orodja za pripravo grafike kot matematični modul za izračunavanje... Med grafično orientiranimi moduli so najbolj pogosti tkinter, ki je tudi del standardnega nabora. Poznamo tudi PyQt5 za naravni izgled oken na Windowsih ter Kivy, posebej prilagojen za grafiko na telefonih sistema [[IOS|IOs]] in [[Android (operacijski sistem)|Android]].

Ima tudi orodja za razvijanje internetnih aplikacij, med najbolj pogosto uporabljena spadajo Django, ki ima svojo posebno knjižnico in deluje večinoma v relaciji s podatkovno bazo, ''Bottle, Flask,'' ''Tornado (orodje), web2py'' in ''Jade''. Večina teh orodij mora uporabnik naložiti s spleta v [[Integrirano razvojno okolje|intergrirano razvijalno okolje]] (''Intergrated development enviroment'', IDE). Zaradi preprostosti Pythona ga včasih uporabljajo za statistično-napovedovalne modele in programe, kot alternativo jeziku [[programski jezik R|R]]. Med najpogosteje uporabljena analitična orodja spadajo [[SciPy]], [[Pandas]] in [[Numpy]]. Večina analitičnih orodji je programiranih v jeziku C za optimalno delovanje in večplatformnega delovanja. Za razvijanje programske opreme pa se uporabljajo predvsem naslednja orodja: ''Buildbot'', ''Trac'' in ''Roundup''. Uporabljajo se tudi orodja za administracijo sistema, kot na primer: ''Ansible'', ''Salt'' in ''OpenStack''. Le-ti sistemi pa uporabljajo način '''MLA''' ('''m'''ulti '''l'''anguage '''a'''rchitecture, večjezična programska arhitektura), najdemo ga tudi v spletnih straneh<ref>{{Navedi splet|title=php - Best practice multi language website|url=https://stackoverflow.com/questions/19249159/best-practice-multi-language-website|website=Stack Overflow|accessdate=2020-08-22}}</ref>. Na področju [[Umetna inteligenca|umetne inteligence]] se Python uporablja zaradi preprostosti in velikega števila uporabnikov navkljub manjši hitrosti izvajanja. Uporabljajo ga [[NASA]],<ref>{{Navedi splet|title=How does NASA use Python? - Quora|url=https://www.quora.com/How-does-NASA-use-Python|website=www.quora.com|accessdate=2020-08-21}}</ref> [[Pixar]], [[Google]], [[Facebook]],<ref>{{Navedi splet|title=How is Python being used at Facebook? - Quora|url=https://www.quora.com/How-is-Python-being-used-at-Facebook|website=www.quora.com|accessdate=2020-08-21}}</ref> [[YouTube]]<ref>{{Navedi splet|title=Developer's Guide: Python {{!}} YouTube|url=https://developers.google.com/youtube/1.0/developers_guide_python?hl=sl|website=Google Developers|accessdate=2020-08-21|language=en}}</ref> in mnoge druge organizacije.

== Zmogljivost in težave ==

Python je bil prvotno napisan za računalnike v 80. letih 20. stoletja, kjer so imeli večinsko samo enojedrne sisteme. Vse niti so tako delovale na enem jedru, ker računalnikov z več jedri preprosto ni bilo veliko. S časom pa so se pojavili računalniki z več jedri v CPE, katere še danes Python ne koristi zaradi ti. GIL (Global Interpreter Lock). V naslednjih letih je pričakovano, da se bo GIL verjetno odstranil s pomočjo ti. podtolmačev ki bi tolmačili vsak na svojem jedru ter komunicirali med seboj. Sicer pa se poraja vprašanje kakšen zmogljvostni vtis bo imela taka implementacija brez GIL na do sedaj napisane enojedrne Pythonove programe.

Ker je Python sam po sebi relativno počasen bodisi zaradi GIL (Global Interpreter Lock), ki dovoli uporabo samo enega [[Jedro (računalništvo)|jedra]] na enkrat, bodisi zaradi dinamičnih tipov ali overheada, ki ga povzročijo pri tekoči izvršitvi, se Python pogosto uporablja na visokonivojski plasti, ki kliče nižjenivojske funkcije, napisane v prevedenem jeziku kot npr. C. Tako povezavo med plastmi je možno doseči s standardno knjižnico <code>ctypes</code> in dinamično povezanimi knjižnicami, ki so zgrajene v C ali drugih prevedenih jeziki. Nestandardni način, ki je sicer industrijsko bolj uveljavljen (še posebej na embedded/AI čip področju) je uporaba nestandardne knjižnice Cython, ki umetno generira kompatibilnost med nizkonivojskimi hitrimi plastmi in visokonivojsko Pythonsko plastjo. To stori z tako imenovanimi <code>.pyx</code> (abstrakcije deklariranih konstruktov) in <code>.pxd</code> (deklaracije eksternih C simbolov) datotekami. V projektu se Cython se konfigurira na nivoju <code>setup.py</code> datoteke.

Poleg glavne implementacije pythonovega tolmača ti. CPython, imamo mnoge druge implementacije, kot npr. PyPy, ki doda JIT (Just-in-time compiler), kar lahko za določen tip aplikacij močno pospeši hitrost programa za nekatere pa močno upočasni hitrost programa.

== Struktura python projekta ==
V splošnem se Python programi pišejo v <code>.py</code> datoteke čeprav so končnice neobvezne. Na prvi vrstici se lahko nahaja ti. shebang line npr. <code>#!/usr/bin/env python3</code>, tj. pot do tolmača (oz. ukaz, ki vrne pot do dolmača), ki bo izvajal sledečo kodo. Podoben princip obstaja v shell/bash skriptah. Shebang vrstica ponavadi ne deluje na Windows OS.

Poleg shebang vrstice imamo tudi coding vrstico, ki določa/namigne tolmaču kateri nabor znakov uporablja ta datoteka, npr: <code># -*- coding: utf-8 -*-</code>.

Če za modul/datoteko vemo, da se lahko uporablja kot vhodna točka programa, potem po konvenciji vanjo zapišemo sledečo kodo:

<syntaxhighlight lang="py">
# Deklaracije/definicije, tisto kar se lahko vnese v druge module

if __name__ == "__main__":
    # Koda ki se izvršuje
    pass
</syntaxhighlight>

Tako ima lahko Python program več vstopnih točk, zaganjamo pa lahko samo eno na enkrat.

Ponavadi se Python moduli nahajajo znotraj paketov ti pa znotraj ti. virtualnih okolji. Virtualno okolje je kot svoj lasten python za specifičen projekt katerega drugi projekti v splošnem ne vidijo (čeprav ga je možno deliti).

Najbolj primitivno virtualno okolje (tj. samo tolmač s <code>pip</code> upravljalcem paketov) je inicializirano s <code>venv</code>. Poleg tega se v projektu nahaja še <code>requirements.txt</code> v katerem so zapisana v obliki semantičnega versioninga imena in verzije odvisnosti (eksternih knjižnic), ki jih pip namesti v virtualno okolje.

Za večji nadzor in ker ni praktično imeti celotnega pythona v istem direktoriju kot dejanski projekt so na voljo ti. angl. package managerji drugega nivoja npr. <code>pipenv</code> in <code>poetry</code>. Pri obeh se ob inicializaciji v projektu zgenerirata dve datoteki oblike <code>*[.toml]</code> in <code>*.lock</code> v TOML datoteki so zapisane odvisnosti (eksterne knjižnice), v autogenerirani (glede na TOML) LOCK datoteki pa SHA128/SHA256 razpršilniki, semantične verzije trenutno nameščenih eksternih knjižnice, indeksi (registri) od kod se te knjižnice nameščajo, ter pogoji namestitve (tj. nekatere knjižnice se ne nemeščajo na npr. Windows OS, itn.). Dejanski tolmač okolja in namesčene knjižnice v tem primeru ponavadi sedijo v enem izmed poddirektorijev <code>$HOME/.virtualenvs</code>.

Poleg package managerjev drugega in prvega nivoja, virtualnih okolji in zgeneriranih datotek, se uporabljata še dve orodji: linter in formater.

Linter je program, ki prebere kodo in strukturo projekta ter programerju vrne morebitne težave oz. nesledenje določenim konvencijam, ki so se izkazale za dobre. Linte (težave) je možno supresirati za določen segment kode z raznimi lint direktivi. Najbolj popularen python linter je <code>pylint</code>.

Formater je program, ki preoblikuje kodo da sledi raznim konvencijam. Npr. <code>autopep8</code> formater preoblikuje kode tako da sledi PEP8 konvenciji ali pa <code>black</code>, ki sledi bolj svoji konvenciji in je pri tem neizprosen (se ga ne da konfigurirati). Tako kot linterje se pravila formatiranja da supresirati za določen segment kode z raznimi format direktivi.

== Program 'Pozdravljen svet' ==
Python je znan po preprostosti kode, zato je eden izmed najbolj priljubljenih jezikov v zadnjem času<ref>{{Navedi splet|title=The Incredible Growth of Python {{!}} Stack Overflow|url=https://stackoverflow.blog/2017/09/06/incredible-growth-python/|website=Stack Overflow Blog|date=2017-09-06|accessdate=2020-08-22|language=en-US}}</ref> ter pri otrocih. Program je skoraj enak svoji [[Psevdokoda|psevdokodi]], tj. besedilu, ki ga programerji pogosto naredijo med razmišljanjem o problemu. V Pythonu se tip ''niz'' (<code>string</code>) označuje z <code>" "</code> ali <code>' '</code>, ki je v spodaj podanem primeru prvi parameter funkcije<ref>{{Navedi splet|title=Python print()|url=https://www.programiz.com/python-programming/methods/built-in/print|website=www.programiz.com|accessdate=2020-08-30}}</ref> <code>print</code>, ki se uporablja za izpis podatkov. V Pythonu obstajata dva tipa komentarjev: <code>#</code>, ki se uporablja za enovrstične komentarje. Docstring <code>""" """</code> se uporablja za dokumentiranje programa vendar to *ni* komentar pač pa samo string, ki sam po sebi nič ne naredi.
<syntaxhighlight lang="python3">
# To bo izpisalo 'Pozdravljen svet', ta vrstica pa bo prezrta
print('Pozdravljen svet')
</syntaxhighlight>

== Spremenljivke ==
V svetu informatike [[spremenljivka]] predstavlja prostor, kamor se shrani neka vrednost. Spremeljivke lahko poimenujemo s poljubnim nizom alfanumeričnih znakov in podčrtajev, a ime se ne sme začeti s številko ali biti ena izmed [[Seznam rezerviranih besed v jeziku Python|rezerviranih besed]].

Definirajo se tako, da jih poimenujemo in jim dodelimo vrednost. V nasprotju z drugimi programskimi jeziki se spremenljivke same prilagodijo pravemu [[Podatkovni tip|podatkovnemu tipu]]. Prevladujejo numerične, nizne in logične spremenljivke. Za preverbo podatkovnega tipa uporabimo funkcijo<code>type()</code>, ki nam vrne tip podanega parametra.

<syntaxhighlight lang="python">pozdrav = "Živjo"   # niz (string)
denar = 100         # celo število (integer)
povprečje = 12.699  # decimalno število (float)
jeVesel = True      # boolean (True ali False), lahko ju tudi izrazimo z 1(True) ali 0(False)
kompleksno_število = 2+5j # kompleksno število (complex)
nič = None # ničelni podatkovni tip (NoneType) ta tip je poseben, saj nima dejanske vrednosti.
seznam = [1, 2, 3] # seznam (list)
slovar = {"Ana": "041 310239", "Berta": "040 318319"} # slovar (dict)
terka = (1, 2, 3) # terka (tuple)

print(type(pozdrav)) # ali katerokoli drugo že definirano spremenljivko</syntaxhighlight>
Tudi objekti, definirani s strani uporabnika, se štejejo kot tip spremenljivke, npr. <code>Uporabnik</code>. Vsaka spremenljivka ima svoje posebnosti zaradi različnih posebnosti v naravi Pythona samega. Tako lahko uporabimo dejstvo, da je vsak podatkovni tip lasten objekt. Tako lahko s spremenljivkami upravljamo tipe po [[Atribut (računalništvo)|atributih]]. Nizne spremenljivke lahko režemo zaradi skupnih lastnosti z kolektivnimi tipi spremenljivk (niz postane <code>list</code> spremenljivka). 
<syntaxhighlight lang="python">
x = "Danes je oblačno"
print(x[3]) # izpiše črko "e", saj Python začne vedno šteti z 0.
print(x[5:]) # izpiše " je oblačno", saj izreže vse pred 5 (šteje se tudi presledek)
print(x[:4]) # izpiše "oblačno", saj izreže vse po 4.
print(len(x)) # izpiše dolžino besede shranjene v spremenljivki x. Izpiše '16'.
print(x[:-3]) # izpiše "a", saj kadar uporabimo znak minus (-), začne šteti od desne proti levi.
</syntaxhighlight>

=== Dostopnost spremenljivke<ref>{{Navedi splet|title=7. Simple statements — Python 3.9.0 documentation|url=https://docs.python.org/3/reference/simple_stmts.html#the-global-statement|website=docs.python.org|accessdate=2020-11-05}}</ref> ===
Poznamo 3 stopnje dostopnosti spremenljivke. To so <code>global</code>, <code>nonlocal</code> in <code>local</code>. Prvostopenjske oz. globalne spremenljivke so definirane izven vseh funkcij, ponavadi na vrhu strani. Dostopne so celotnemu programu, ki pa jih lahko spreminja, a se ji stopnja med spreminjanjem vrednosti ne spremeni. Drugostopenjske spremenljivke, tako <code>local</code> kot <code>nonlocal</code>, so pa definirane znotraj posameznih enot programa (funkcij, objektov, ...) in niso dostopne programu na globalni ravni. <code>local</code> se uporablja znotraj ne-gnezdenih funkcij, <code>nonlocal</code> pa uporabljamo v več-ravenskih funkcijah.<syntaxhighlight lang="python3">
ime = 'Janez'
# Spremenljivka ime je globalna

def pozdravi():
    pozdrav = 'Dober dan' # Spremenljivka je lokalna
    print(pozdrav)
print(pozdrav) # Vrne napako

# Primer upoerabe spremenljivke z statusom nonlocal
def pozdravi_z_imenom():
    pozdrav = 'Dober dan'
    def ime():
        nonlocal ime 
        ime = 'Marija'
        print(ime)
    print('{}, {}'.format(pozdrav, ime))
</syntaxhighlight>
Funkcije <code>locals()</code> in <code>globals()</code> vrnejo <code>dict</code> kjer so ključi imena lokalnih in globalnih spremenljivk v trenutnem dosegu.

== Niz ali string ==
V računalniškem svetu je string ali niz zaporedje črk ali znakov v obliki spremenljivke ali izhodne sekvence. V Pythonu je niz spremenljiv bodisi v velikosti ali v vsebini. Definiran je kot matrica bytov''',''' ki shranijo posamezen sekvenčni del oziroma črko glede na črkovno notacijo. V sebi lahko v obliki niza nosi tudi druge podatkovne tipe, npr. cela števila ali nize podatkov.

=== Konkatinacija niza<ref>{{Navedi revijo|date=2020-10-07|title=Concatenation|url=https://en.wikipedia.org/w/index.php?title=Concatenation&oldid=982367644|language=en}}</ref> ===
Konkatinacija niza se uporablja, kadar moramo združiti več manjših nizov (string) objektov v končni izpis. Pri tem se uporablja operator <code>+</code>. Če hočemo konkatinirati druge podatkovne tipe jih moramo najprej prevesti v niz (string). V Pythonu je konkatinacija niza izvedena ob času izvedbe programa in njeni rezultati niso znani vnaprej. V primeru absolutnega niza z izhodnimi sekvencami pa je rezultat konkatinacije niza znan že ob izgradnji programa v Pythonovem predpomnilniku. Velja tudi izjema pri več-vrstičnih nizih. Ti so označeni z <code>""" """</code> ali z <code><nowiki>''' '''</nowiki></code>. Pri tem je upoštevana struktura niza z vsemi prelomi vrstic. Ta odlika je velikokrat uporabljena pri večvrstičnih komentarjih in dokumentaciji funkcij.
<syntaxhighlight lang="python">
x = "Pozdravljen"
y = "svet"
print(x + " " + y)
# izpis konzole:   
#   Pozdravljen svet

# primer prevoda podatkovnega tipa
jeŽalosten = False
kolikoLet = 100000
jeŽalosten = str(jeŽalosten)
kolikoLet = str(kolikoLet)

print("Ali si žalosten: " + jeŽalosten)
print("Koliko let imaš: " + kolikoLet)
# izpis konzole:
#   Ali si žalosten: False
#   Koliko let imaš: 100000

#Primer večvrstičnega niza
print("""Rad imam
Python 3.8.""")
#izpis konzole:
#   Rad imam
#   Python3.8

</syntaxhighlight>
Za dva niza S<sub>1</sub> in S<sub>2</sub> je konkatinacija niza S<sub>1</sub>S<sub>2</sub> sestavljena iz nizov v obliki ''ab'', kjer je ''a'' del niza S<sub>1</sub>, ''w'' pa je del niza S<sub>2</sub>. To lahko izrazimo z <math>S_1S_2 = \{vw: v \in S_1, w \in S_2\}</math>. Velikokrat pa se znajdemo v primeru konkatinacije niza in samostojnega znaka. To pa lahko izrazimo z <math>S_1w = \{vw: v \in S_1\}</math> in <math>vS_2 = \{vw: w \in S_2   \}</math>.

=== Osnovno formatiranje niza<ref>{{Navedi splet|title=PyFormat: Using % and .format() for great good!|url=https://pyformat.info/|website=pyformat.info|accessdate=2020-11-01}}</ref> ===
Preprosto formatiranje niza je verjetno največkrat uporabljena oblika formatiranja in/ali konkatinacije niza. Uporabljamo ga v primeru enakega vrstnega reda parametrov v relativno majhnem obsegu združenih elementov. Zaradi dveh generacij Pythona (2 in 3), se je tudi način formatiranja spremenil. Tako poznamo stari in novi slog. Stari deluje tudi v 3. generaciji Pythona, novi pa ne deluje obratno. V novem slogu formatiranja Python kliče <code>__format__()</code> metodo, ki je implementacija že vgrajene funkcije <code>format()</code> v razredu <code>object</code>. 

Formatiranje pa ne omogoča samo konkatinacije, ampak tudi poravnavo 2 nizov. Po privzetih parametrih formatiranje 2 nizov zavzame samo toliko prostora, kot ga potrebuje. V starem načinu je zamik desnosučni, v novem pa levosučni. Mogoča je uporaba vseh primitivnih podatkovnih tipov, pri številih z decimalno vejico pa jim moramo podati tudi število mest za vejico.
<syntaxhighlight lang="python">
x = 5
y = "Jure"
k = "Nina"
e = 2+3j

# prvi primer (novejši način)
print(y + " je vesel, saj je dobil oceno {}".format(x))
# ali pa uporabimo znak % (starejši način)
print(y + " je vesel, saj je dobil oceno %d"%x)
# V tem primeru funkcija 'format' spremeni vrednost vseh y, k, e vrednosti v niz. Vpiše jih v glavni niz objekt po vrsti z začetkom od 0 do 2
print("{0} in {1} sta skupaj rešila enačbo {2}".format(y, k, e))
# Tukaj je posebna vrsta niza, ki omogoča formatiranje niza med dejanskim nizom. Gre za novejši način.
print(f"{y} + {k} = {x} + {e}")
#Zamikanje besede z uporabo format funkcije, novejši način.
print('{:>10}'.format('test'))

</syntaxhighlight>

== Matematični operatorji ==
Matematični [[Operator (matematika)|operatorji]] v Pythonu so posebni rezervirani simboli, ki izvedejo aritmetične ali logične operacije. Operatorji delujejo na operande. Operatorji se v Pythonu delijo na unarne in binarne. Poznamo [[Matematična operacija|aritmetične]], logične, bitne in primerjalne operatorje. Python v izrazih sledi uporabi oklepajev in precedenci vseh operatorjev. 

Izračun se izvaja v času izvajanja programa (čeprav to ni nujno, določene stvari se lahko izračunajo pred izvajanjem zaradi konstantne narave), medtem ko se spremenljivke zapišejo že med izgradnjo programa. Med tekom kode procesor najprej izvede <code>()</code>, nato sledijo klici [[Funkcija|funkcij]] (<code>f(args)</code>), sledi procesiranje kolektivnih spremenljivk (<code>x[indeks:indeks]</code> in <code>x[index]</code>). Program nato omogoči dostop atributom spremenljivke (<code>x.attribute</code>). Izvede se [[potenciranje]], sledijo aritmetični operatorji z [[Negacija|negacijo]] na čelu. Kot zadnji pridejo na vrstno bitni operatorji z primerjalnimi op. ter logični op. na koncu.
<syntaxhighlight lang="python">
# Osnovne operacije
x + y  # seštevanje
x - y  # odštevanje 
x * y  # množenje
x / y  # deljenje (zaokroženo na decimalno vrednost)
x // y # deljenje
x ** y # potenciranje (produkt x-ov y-krat)
x % y  # modulo (ostanek pri deljenju)

# Primerjalni operatorji
x == y # primerjava
x > y # je večje 
x < y # je manjše
x >= y # je večje ali je enako
x <= y # je manjše ali je enako
x != y # ni enako

# Logični operatorji
x = True
y = False
x and y # konjunkcija
x or y # disjunkcija
not y # negacija

# Bitni operatorji
x & y # bitni AND
x | y # bitni OR 
~ x # bitna negacija
x ^ y # bitni XOR
x >> 2 # bitni desni premik
x << 2 # bitni levi premik

# Vse račune lahko shranjujemo v spremenljivke
a = 2 + 5 # shrani rezultat računa v spremenljivko a
print(x) # izpiše vrednost a
print(3 + 7 * 2) # Izpiše 17, ker ima množenje prednost
print((5 - 7) * 4) # Izpiše -8, ker ima operacija v oklepaju prednost

</syntaxhighlight>
<!-- Python konzola ima vgrajeno računalo tako da ni potrebno uporabljati funkcije print, z izjemo če razvijamo v IDE --><small><sub>.</sub></small>

=== Razlika med standardnimi in hitrimi operatorji<ref>{{Navedi splet|title=Inplace vs Standard Operators in Python|url=https://www.geeksforgeeks.org/inplace-vs-standard-operators-python/|website=GeeksforGeeks|date=2017-01-10|accessdate=2020-11-06|language=en-US}}</ref> ===
Metoda <code>__add__</code> (funkcija baznega razreda <code>object</code>) je zadolžena za izvedbo navadnega seštevanja. To pomeni da se <code>a + b</code> zapiše v spremenljivko <code>c</code> brez spremembe argumentov [[Seštevanec|seštevancev]]. Hitra metoda <code>__iadd__</code> je ravno tako zadolžena za izvedbo seštevanja, a se rezultat namesto v drugo spremenljivko zapiše v spremenljivko <code>a</code> (<code>a = a + b</code>). Hitri operatorji so naslednji:<syntaxhighlight lang="python3">
#Hitre operacije namenjene dodelitvi vrednosti izraza v konjunkciji z drugo spremenljivko
x += y # dodelitev seštevka (ekvivalent x = x + y)
x -= y # dodelitev odštevka (ekvivalent x = x - y)
x *= y # dodelitev zmnožka (ekvivalent x = x * y)
x /= y # dodelitev količnika zaokroženega na najbližjo celoštevilsko vrednost (ekvivalent x = x / y)
x //= y # dodelitev količnika (ekvivalent x = x // y)
x **= y # dodelitev produkta x-ov y-krat (ekvivalent x = x ** y)
x %= y # dodelitev ostanka pri deljenju (ekvivalent x = x % y)
x <<= y # ekvivalent x = x << y
x >>= y # ekvivalent x = x >> y
x &= y # ekvivalent x = x & y
x |= y # ekvivalent x = x | y
x ^= y # ekvivalent x = x ^ y

</syntaxhighlight>

=== Definiranje operatorjev znotraj objektov<ref>{{Navedi splet|title=Operator Overloading in Python|url=https://www.geeksforgeeks.org/operator-overloading-in-python/|website=GeeksforGeeks|date=2018-12-10|accessdate=2020-11-06|language=en-US}}</ref> ===
Definiranje operatorjev znotraj objektov pomeni dodajanje nove funkcionalnosti operatorju. Operator <code>+</code> lahko sešteje oz. konkatinira spremenljivke tipa <code>string</code> in <code>int</code> ali <code>int</code> in <code>float</code> itd. To je definirano v tako baznem razredu <code>string</code> kot v baznem razredu <code>string</code> . V Pythonu lahko znova definiramo vse operatorje, ne moremo pa ustvariti novih. Operatorji so definirani kot posebne funkcije baznega razreda <code>Builtin</code>, najdemo jih pod imenom <code>__<ime operatorja>__</code>.<syntaxhighlight lang="python3">
class A:
    def __init__(self, parameter):
        self.parameter = parameter
    
    #Definiramo "drugačno" ozadje funkcije __add__
    def __add__(self, other):
        return self.parameter + other.parameter

obj1 = A('Janezek')
obj2 = A('Micka')
print(obj1 + obj2)
#Konzola izpiše JanezekMicka
</syntaxhighlight>

== Kolektivni podatkovni tipi ==
Python pozna kar nekaj tipov spremenljivke, s katerimi lahko interpretiramo oz. integriramo množice. To so <code>list</code>, <code>tuple</code>, <code>set</code> in <code>frozenset</code>. Vsaka je malo drugačna, toda vse 4 lahko razdelimo v 2 skupini. Razdelimo jih glede na status uredbe spremenljivke. Spremenljivka je lahko ''spremenljiva'', to sta <code>list</code> in <code>set</code>. Nasprotno je lahko kolektivni tip ''nespremenljiv,'' to sta <code>tuple</code> in <code>frozenset</code>. ''Nespremenljiv'' pomeni, da množici vrednosti programsko ne moremo dodati ene ali več vrednosti. Vrednosti znotraj množice ponavadi vsebujejo več tipov spremenljivk, z dodajanjem <code>metaclass</code> pa jih lahko naredimo homogene. 

Vsi kolektivni tipi, razen <code>dict</code>, vsebujejo samo enojne vrednosti, medtem ko <code>dict</code> vsebuje pare ''ključ: vrednost'' kot [[urejeni par]]. Pri teh parih so lahko spremenljivke različnih tipov, ni pa nujno. Če je prva komponenta <code>dict</code> ključa ''a'', druga pa ''b,'' lahko to izrazimo z <math>(a, b) := \{\{\{a\}, \{a, b\}\}</math>. Število elementov v vseh kolektivnih tipih je omejeno in temelji na operacijskem sistemu. Če je sistem 32-bitni, je maksimum <math>2\times31^2-1</math>, v 64-bitnem pa <math>2\times63^2 - 1</math>.

Spremenljivke v kolektivnih tipih niso prave instance njihovih baznih objektov, ampak so to referenčne točke, ki vodijo do njihovega izvora<ref>{{Navedi splet|title=An Introduction to Python Lists|url=http://effbot.org/zone/python-list.htm#performance|website=effbot.org|accessdate=2020-11-06|archive-date=2020-11-06|archive-url=https://web.archive.org/web/20201106232826/http://effbot.org/zone/python-list.htm#performance|url-status=dead}}</ref>. Zato je velikost ''množice'' odvisna od števila elementov in ne od velikosti objektov. Čas iteracije skozi celoten seznam je ne glede na dolžino enak <math>O(1)</math>, čas dodajanja pa je konstanta.
<syntaxhighlight lang="python">
znamke = ["Ferrari", "BMW", "Honda", "Alfa"] # to je list z 4 vrednostmi enakega tipa podatkov
vse = (0, "Vito", 44, True, None, "Živjo", 2.44) # to je tuple, ki lahko vsebuje katerikoli tip podatka
tabela_ocen = {"Miha":4, "Jure":2, "Jaz":5, "Nekdo":1, "Maja":4, "Nina":3} 
# to je dict vsebuje key and value. Key so v tem primeru imena, vsako ima svojo oceno torej value. Torej tuple ima key=string in value=intiger podatke."""

# vse podatke lahko izpišemo s print funkcijo
print(znamke)
print(vse)
print(tabela_ocen)
print(type(znamke))
print(type(vse))
print(type(tabela_ocen))

# izpis konzole
#['Ferrari', 'BMW', 'Honda', 'Alfa']
#(0, 'Vito', 44, True, None, 'Živjo', 2.44)
#{'Miha':4, 'Jure':2, 'Jaz':5, 'Nekdo':1, 'Maja':4, 'Nina':3}
#<type 'list'>
#<type 'tuple'>
#<type 'dict'>
</syntaxhighlight>

=== Urejanje kolektivnih podatkovnih tipov ===
Časovna kompleksnost dodajanja elementov<ref>{{Navedi splet|title=Why is the time complexity of python's list.append() method O(1)?|url=https://stackoverflow.com/questions/33044883/why-is-the-time-complexity-of-pythons-list-append-method-o1|website=Stack Overflow|accessdate=2020-11-06}}</ref> k listi je ''ublaženi'' <math>O(1)</math>. Če imamo <code>list</code> A z močjo <math>m(A) = 8</math> in ji hočemo dodati 50 elementov, se zgodi naslednje: 

Prvih 8 elementov je potisnjenih v <math>O(1)</math>, 9. sproži relokacijo in odpre ostalim 8 dostop v <math>O(1)</math>. V 17. iteraciji se sproži relokacija 16 prejšnjih členov in 15 novih členov pride v <math>O(1)</math>. 33. ponovitev zanke sproži novo relokacijo 32 prejšnjih členov in v <math>O(1)</math> pride 17 novih. Po vseh relokacijah imamo časovno kompleksnost <math>O(1)</math>, v kateri je 56 kopij in 3 realokacije v <math>O(n)</math>, za <math>n = 8, 16, 32</math>. Če upoštevamo, da je to geometrijska serija je to asimptotično enako <math>O(n)</math> za ''n'' ''= končna velikost seznama''. To pomeni, da je celotna operacija potiskanja n predmetov na seznam <math>O(n)</math>. Če to amortiziramo na element, je <math>O (n) / n = O (1)</math>. Če je seznam dolg, pa se lahko časovna kompleksnost poveča tudi na <math>O(n^2)</math>.
<syntaxhighlight lang="python">
x = ["A", "B", "C", "D"]
print(x[2])
# konzola izpiše C saj se list začne šteti z 0

# da dodamo vrednost listu uporabimo metodo append
x.append("E") # to doda x listu na konec vrednost "E"

# da odstranimo vrednost listu uporabimo metodo pop
x.pop(1) # izbriše drugo vrednost na listu v tem primeru "B"
print(x)

# konzola izpiše 
['A', 'C', 'D', 'E']

# če nevemo katero število pripada določeni vrednosti na listu uporabimo metodo count
št_a = x.count("A")
print(št_a) # izpiše 0 saj je a na prvem mestu.

# Kolektivne podatkovne tipe je mogoče tudi gnezditi.
j = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
# Spremenljivka je list listov torej če uporabimo enonivojsko klicanje podatkov preko [] operatorja
print(j[0]) # Izpiše [1, 2, 3]
# Do dostopamo do notranje vsebine recimo števila 5
print(j[1][1]) # Izpiše 5
</syntaxhighlight>
Za vsak kolektivni podatek obstaja vsaj 5 metod.

== Vnos ==
Vnos se izraža z 2 built-in keyword-oma <code>input</code> in <code>raw_input</code>. Če uporabimo <code>raw_input</code> potem se vsak naš vnos šteje kot niz, če pa uporabljamo <code>input</code> moramo pred njega vstaviti tip podatka katerega hočemo pridobiti na primer: <code>int(input("Vnesi število: "))</code>, za vnos števila. <code>raw_input</code> ni več v uporabi od Python verzije 3.6.x 

<syntaxhighlight lang="python">
# primer raw_input keyworda
x = raw_input("Vnesi svoje ime: ")
print("Pozdravljen " + x + "!")
print("Dolžina tvojega imena je {}".format(len(x)))  # len() keyword se uporablja pri ugotavljanju dolžine določene besede

# primer input keyworda
y = input("Vnesi svoje ime: ") # Ekvivalent starejši raw_input
k = int(input("Vnesi svojo starost: "))

print("Tvoje ime je " + y)
print("Star si {}".format(k)) # intiger tipe vedno formatiramo saj se jih ne more konkatinirati s string, razen v primeru prevoda podatkovnega tipa.
</syntaxhighlight>

== Pogojni stavki ==
Pogojni stavki se uporabljajo predvsem za zastavljanje pogojev skozi katere mora neka vrednost priti, da se nekaj izvaja. Izraža se jih s ključnimi besedami <code>if</code>, <code>elif</code>, <code>else</code> in <code>match</code> (dodan v verziji 3.10).
<syntaxhighlight lang="python">
# primer if-elif-else stavka
barva = input("Vnesi svojo najljubšo barvo: ")
if barva == "rdeča" or barva == "modra":
   print("Zelo lepo")
elif barva == "zelena" or barva == "rumena":
   print("Lepo")
elif barva == "črna" or barva == "bela" or barva == "roza":
   print("Ne najbolje")
elif barva == "rjava" or barva == "oranžna" or barva == "lila":
   print("Slaba izbira")
else:
   print("Ne poznam te barve")

# primer if-else stavka
s = int(input("Prosim vnesi svojo starost: "))
if s < 18:
   print("Dostop ni dovoljen.")
else:
   print("Dobrodošli")

# matematični primer 
if 9 + 1 == 10:
   print("Pravilno")
elif 9 + 1 != 10:
   print("Narobe")

</syntaxhighlight>

<syntaxhighlight lang="python">
# primer nested stavka
c = input("Vnesi črko: ")
k = int(input("Vnesi številko: "))
if c in ['A','B','C','D','E','F']:
   if k > 50:
      print("Uspešno")
   elif k <= 40:
      print("Skoraj uspešno")
   else:
      print("Ni uspešno")
elif c in ['K','L','M','N','O']:
   print("Bravo zmagal si")
elif len(c) < 1 and len(c) > 1:
   print("Moraš vpisati samo eno črko")
else:
   print("Napaka")
</syntaxhighlight>

<syntaxhighlight lang="python">
# primer walrus operatorja v if-u
if c := input("Vnesi niz: "): # if se izvrsi samo v primeru če je bool(c) == True
   if c.startswith("A"):
      print(f"Vnesel/vnesla si niz, ki se začne z A: {c}")

# to zgoraj je samo krajša oblika za naslednje
c = input("Vnesi niz: ")
if c and c.startswith("A"):
    print(f"Vnesel/vnesla si niz, ki se začne z A: {c}")
</syntaxhighlight>

<syntaxhighlight lang="python">
# primer match stavka
c = "Žaba"
def zvok():
    match c:
       case "Žaba": return "Reganje"
       case "Pes": return "Lajanje"
       default: return "Neznano"

zvok() # vrne "Reganje"
</syntaxhighlight>

== Zanke ==
Zanke so ukazi, s katerimi lahko večkrat izvedemo nek del kode. V Pythonu poznamo 2 tipa zank: <code>for</code> in <code>while</code>.
Zanka <code>for</code> ponovi nek del kode za vsakega člana nekega iterativnega podatkovnega tipa, s stavkom <code>while</code> pa izvajamo kodo, dokler nek pogoj velja.
<syntaxhighlight lang="python>
# primer for zanke
pozdravi = ['Živjo', 'Zdravo', 'Pozdravljeni']
for x in pozdravi:
    print(x)

# ali pa
for i, x in enumerate(pozdravi):
    print(i, x) 
# Vrednost i in x sta razpakirana iz enumerate(pozdravi).

# izpis konzole 
Živjo
Zdravo
Pozdravljeni

0, Živjo
1, Zdravo
2, Pozdravljeni

# primer while zanke
p = "12345"
while True:
   r = input("Vnesi geslo: ")
   if r != p:
      print("Napačno Geslo")
   elif r == p:
      print("Dobrodošli")

# izpis konzole
Vnesi geslo: 54321
Napačno Geslo
Vnesi geslo: 12345
Dobrodošli
</syntaxhighlight>

== Moduli ==
Vsaka Python datoteka predstavlja natanko en modul. Modul lahko vpeljemo v drug modul s stavkom <code>import</code> oz. s stavkom <code>from import</code>. Vsi vnešeni konstrukti (paketi, moduli, funkcije, itd.) so lahko poimenovani drugače za modul v katerega vnašamo z besedo <code>as</code>.

'''pozdravi.py'''
<syntaxhighlight lang="python">
def reči_živjo(ime):
    print(f"Živjo {ime}")
</syntaxhighlight>

'''glavni.py'''
<syntaxhighlight lang="python>
import pozdravi as p

x = "Anastazija", "Špela", "Marija"

for w in x:
    p.reči_živjo(w)

# izpis konzole
Živjo Anastazija
Živjo Špela
Živjo Marija
</syntaxhighlight>

Vsi stavki <code>import</code> vnašajo relativno na lokacijo trenutnega modula v datotečnem sistemu. Vnašamo lahko zato tudi npr. <code>from ..A import b as c</code> vnese modul A, ki se nahaja v starševskem direktoriju glede na trenutni modul v katerem smo to napisali.

== Paketi ==
Paket (angl. package) je skupek modulov v nekem direktoriju. Minimalni Python paket ustvarimo če imamo v nekem direktoriju datoteko <code>__init__.py</code>. V ta direktorij nato lahko dodajamo razne module. Pakete se lahko tako kot module vnaša z <code>import</code> stavkom. Ko vnesemo paket se avtomatično izvrši <code>__init__.py</code>.

== Funkcije ==
Funkcija je del kode, ki se izvede, ko jo kličemo. Z uporabo funkcij se izognemo večkratnemu ponavljanju iste kode, hkrati pa izboljšamo njeno berljivost.
V funkcijo lahko podamo vhodne podatke, imenovane [[Parameter (računalništvo)|parametri ali argumenti]], s katerimi funkcija lahko operira. Pogosto nam funkcija tudi vrne podatke. Funkcije lahko gnezdimo. Funkcije lahko podajamo kot parametere, saj so konec koncev samo kazalci na različne lokacije pomnilnika ter tako z njimi formiramo sintaktični sladkor, funkcijske dekoratorje (poznamo namreč tudi razredne dekoratorje). Anonimne funkcije se imenujejo lambde. 
Definiramo jih z besedo <code>def</code> (izjema so neimenovane funkcije <code>lambda</code>), ki ji sledi ime, nato pa seznam arguentov in dvopičje. V naslednjih vrsticah napišemo vsebino funkcije, zamaknjeno za 1 odmik.
<syntaxhighlight lang="python">
# primer gnezdene funkcije
def a():
    def b():
       print(42)
    b()
    print(88)

a() // izpise: 42 in v novi vrstici 88
b() // napaka: ta funkcija je definirana v resoluciji a()-ja ne v globalni resoluciji

# primer funkcije podane kot parameter
def a(fn):
    print("kličem fn()")
    fn()

def b():
    print("v b()")

a(b) # izpise "kličem fn()" nato pa še "v b()" v novi vrstici

# zgornje se lahko zapiše s funkcijskim dekoratorjem sledeče, vendar je bolj pogosto, da 
def a(fn):
    def wrapper():
        print("kličem fn()")
        fn()
    wrapper()

@a
def b():
    print("v b()")

b() # izpiše "kličem fn()" nato "v b()" v novi vrstici

@a
def c():
    print("v c()")

c() # izpiše "kličem fn()" nato "v c()" v novi vrstici
</syntaxhighlight>
<syntaxhighlight lang="python">
def seštej(x, y):
    print("Rezultat = {}".format(x + y))

seštej(2, 4) # klic funkctije 
# izpis
6

# Funkcija Seštej je ubistvu tako miniaturna, da jo lahko zapišemo kot lambdo
seštej = lambda x, y: x + y
print(seštej(2, 4)) # Izpiše 6
</syntaxhighlight>
<syntaxhighlight lang="python">
# primer funkcije brez parametrov
def zahtevaj_vpis():
    uporabniško_ime = input("Vnesi uporabniško ime: ")
    geslo = input("Vnesi geslo: ")
    if len(geslo) < 6:
       print("Geslo more vsebovati več kot 6 znakov")
    else:
       print("Dobrodošel uporabnik {}".format(uporabniško_ime))

# primer funkcije s poimenovanimi parametri
# če drugi argument ni podan, se upošteva y=1
def inkrement(x, y=1):
    return x+y

# primer funkcije s pozicijskimi parametri
def odštej(a, b):
    return a-b

število = 3
rezultat = inkrement(3)
print("3 + 1 = " + str(rezultat))
print("5 - 7 = " + str(odštej(5, 7)))

# izpis konzole 
3 + 1 = 4
5 - 7 = -2
</syntaxhighlight>
Funkcijo lahko pokličemo tudi v drugi funkciji saj so vse funkcije globalne. Z izjemo metod definiranih v '''UDR'''.
<syntaxhighlight lang="python">
def pozdravi(ime):
    print("Živjo "+ime)

def vprašanje():
    i = raw_input("Vnesi ime: ")
    pozdravi(i)     

vprašanje()
# izpis konzole 
Vnesi ime: Nekdo
Živjo Nekdo
</syntaxhighlight>
Podatkovni tip parametrov je lahko namignjen z ti. angl. type hinting-om vendar to *ne* zagotovi deklariranega tipa (oz. statičnega tipkanja) in je samo v pomoč IDE okoljem pri indeksiranju knjižnice.
<syntaxhighlight lang="python">
def odštej(a:int, b:int):
    print("{}".format(a + b))

def prepoznaj_tip(t:(list, dict))
   if type(t) is type(list):
      print("Tip je list")
   elif type(t) is type(dict):
      print("Tip je dict")
   else:
      print("Tip ni prepoznan")
</syntaxhighlight>
''' Primeri Funkcij '''
<syntaxhighlight lang="python">
import time
def štej(od, do, zamik=0.5):
    while od < do:
          od = od + 1 # ali pa z uporabo hitrega operatorja od += 1
          print(od)
          time.sleep(zamik) # ustavi izvajanje za zamik sekund

def vnos():
    ime = input("Vnesi ime: ")
    priimek = input("Vnesi priimek: ")
    print(f"Pozdravljen {ime} {priimek}")

# tukaj se uporablja ti. nested funkcije pri kateri je lahko funkcija v funkciji
def kalkulator():
    def seštej(x, y):
        return x + y

    def odštej(x, y):
        return x - y

    def množi(x, y):
        return x * y

    def deli(x, y):
        return x / y

    def potenciraj(x, y):
        return x ** y

    def moduliraj(x, y):
        return x % y
    
    print("Izberi možnost")
    print("Seštevanje = 1")
    print("Odštevanje = 2")
    print("Množenje = 3")
    print("Deljenje = 4")
    print("Potenciranje = 5")
    print("Moduliranje = 6")
    o = str(input("Izbira: "))
    p = int(input("Prvi: ")
    d = int(input("Drugi: ")
    if o == "1":
       seštej(p, d)
    elif o == "2":
       odštej(p, d)
    elif o == "3":
       množi(p, d)
    elif o == "4":
       deli(p, d)
    elif o == "5":
       potenciraj(p, d)
    elif o == "6":
       moduliraj(p, d)
    else:
       print("Neznana operacija.")

kalkulator()
# izpis konzole
Izberi možnost
Seštevanje = 1
Odštevanje = 2
Množenje = 3
Deljenje = 4
Potenciranje = 5
Moduliranje = 6
Izbira: 2  # jaz napisal 2
Prvi: 10
Drugi: 4

# izpis funkcije
6
</syntaxhighlight>

== Konteksti ==
Konteksti so deli kode, v katerih se določene surovine inicializirajo in deinicializirajo avtomatično. Kontekste se definira z ti. <code>contextlib</code> standardno knjižnico. Najlažje je demonstrirati koncept na primeru branja iz datoteke.

<syntaxhighlight lang="py">
# Primer brez branja datoteke konteksta
fp = open("datoteka.txt", "rt")
vsebina = fp.read()
print(vsebina)
fp.close()
</syntaxhighlight>

Medtem ko se z kontekstom lahko s pomočjo <code>with</code> ključne besede zapiše:

<syntaxhighlight lang="py">
with open("datoteka.txt", "rt") as fp:
    vsebina = fp.read()
    print(vsebina)

# fp.close() ni potreben saj bo kontekstni upravljavec sam zaprl datoteko.
</syntaxhighlight>

Kontekste je možno tudi gnezditi ali pa jih inicializirati več na istem nivoju.

== Dekoratorji ==
Funkcije ter razrede lahko dekoriramo z dekoratorjem tik nad definicijo funkcije oz. razreda z <code>@ime_dekoratorja</code>.

== Iteratorji ==
Vsak kolektivni podatkovni tip lahko spremenimo v iterator z vgrajeno funkcijo <code>iter()</code>. Ko dobimo iterator lahko nanj nato kličemo funkcijo <code>next()</code>, ki vrne nasledni element iz iteratorja. Primer:
<syntaxhighlight lang="python">
ime = "Anastazija"
ime_iterator = iter(ime)
assert next(ime_iterator) == "A" # propade če prva črka ni A.
</syntaxhighlight>

== Generatorji ==
Generatorji so funkcije, ki lahko začasno prekinejo delovanje nato pa nadaljujejo. Delovanje se prekine z rezervirano besedo <code>yield</code>. Poleg začasne prekinitve imajo generatorji še popolno prekinitev normalno z besedo <code>return</code>. Primer:
<syntaxhighlight lang="python">
def naravna_stevila():
    num = 0
    while True:
        yield num
        num += 1
</syntaxhighlight>
Vsak klic zgornje generatorske funkcije vrne število za 1 večje od prejšnjega.
Možno je konstruirati generator generatorjev itd. veliko uporabnih funkcij najdemo v standardni knjižnici <code>itertools</code> ter še bolj napredne funkcije v nestandardni knjižnici <code>more_itertools</code>.

== Razredi ==
Razredi lahko vsebujejo funkcije. Funkcije v razredu se imenujejo metode. Razrede se inicializira tako da dobimo novo instanco z <code>__init__</code> predefinirano build-in funkcijo. Pod to globalno predifinicijo spadajo tudi <code>__delattr__</code>, <code>__format__</code>, <code>__getattribute__</code>, <code>__hash__</code>, <code>__long__</code>, <code>__native__</code>, <code>__new__</code>, <code>__call__</code>, <code>__repr__</code>, <code>__nonzero__</code>, <code>__sizeof__</code>, <code>__setattr__</code>, <code>__unicode__</code>, <code>__str__</code> in drugi. Vsaka definicija od naštetih zgoraj ima svoj pomen.
<syntaxhighlight lang="python">
# glavni razred
class A:
    def __init__(self): # klic konstruktorja
        print("Inicializeran razred A")

# podrazred
class Z(A):
    def __init__(self):
        super(Z, self).__init__(A)  # klic superkonstruktorja

class U(Z, A):
    def __init__(self, m1, m2):
        super(Z, U, A, self).__init__(m1, m2)  # klic superkonstruktorja s parametri

# primer nelogičnega oziroma nepravilnega razreda
class B:
    def __init__(self):
        pass

# novo definirane globalne spremenljivke v razedu B
B.ime = "Tone"
B.priimek = "Altgr"

r = B.ime # objekte in njihove člane lahko shranjujemo v spremenljivke
print(r)
        

# primer razreda za osebe
class Oseba:
    def __init__(self, ime:str, priimek:str, starost:int, email:str):
        self.ime = ime # če damo pred objek parameter self lahko dostopamo do njegovih atributov
        self.priimek = priimek
        self.starost = starost
        self.email = email

        podatki = [[], []] # multidimenzionali list
        podatki[0].append(ime)
        podatki[0].append(priimek)

        podatki[1].append(starost)
        podatki[1].append(email)

    def zahtevaj_podatke(self): # funkcija za klic izpisa podatkov na formatni način
        print("Ime: {}".format(self.ime))
        print("Priimek: {}".format(self.priimek))
        print("Starost: {}".format(self.starost))
        print("Email: {}".format(self.email)

    def zahtevaj_dimenzije(self):
        print(podatki)

Jaz = Oseba("Null", "PError", 15, "abc.PError@unknown.abc") 
# Jaz postane Object Oseba z določenimi člani npr. ime. ter metodami za interpretacijo objekta ali postaktivnost tega objekta oziroma njegovih članov.
Jaz.zahtevaj_podatke()

# izpis konzole 
Ime: Null
Priimek: PError
Starost: 15
Email: abc.PError@unknow.abc

# ali 
print(Jaz.ime) # . pomeni član nekega kolektiva v razredu.
print(Jaz.priimek)
print(Jaz.starost)
print(Jaz.email)
</syntaxhighlight>

===Referenčna izvedba===
CPython je referenčna izvedba Pythona. Napisano je v jeziku [[C]], ki ustreza standardu C89 z več izbranimi funkcijami C99 (s poznejšimi različicami C se šteje za zastarele;<ref>{{navedi splet|title=Mailman 3 Why aren't we allowing the use of C11? - Python-Dev - python.org|url=https://mail.python.org/archives/list/python-dev@python.org/thread/PLXETSQE7PRFXBXN2QY6VNPKUTM6I7OD/|access-date=2021-03-01|website=mail.python.org|language=en|archive-date=14 April 2021|archive-url=https://web.archive.org/web/20210414203313/https://mail.python.org/archives/list/python-dev@python.org/thread/PLXETSQE7PRFXBXN2QY6VNPKUTM6I7OD/|url-status=live}}</ref> CPython vključuje lastne razširitve C, vendar razširitve drugih proizvajalcev niso omejene na starejše različice C, lahko jih npr. Implementiramo s C11 ali [[C++]]). Program Python prevede v vmesno bajtno kodo, ki jo nato izvede navidezni stroj.<ref>{{navedi knjigo|title=Introduction to Machine Learning with Python|url=https://python.engineering/introduction-to-machine-learning-with-python/|author=Andreas C. Müller, Sarah Guido|ISBN=9781449369415|publisher=O'Reilly Media|date=2016|access-date=2021-09-27|archive-date=2021-09-06|archive-url=https://web.archive.org/web/20210906163307/https://python.engineering/introduction-to-machine-learning-with-python/|url-status=dead}}</ref>

CPython je razdeljen z veliko standardno knjižnico, napisano v mešanici C in domačega Pythona. Na voljo je za številne platforme, vključno z operacijskim sistemom Windows (začenši s Python 3.9, namestitveni program Python se namenoma ne namesti v operacijski sistem [[Windows 7]] in 8; [[Windows XP]] je bil podprt do Python 3.5) in v večini sodobnih sistemov, podobnih Unixu, vključno z macOS (in Apple M1 Mac, od Pythona 3.9.1, z eksperimentalnim namestitvenim programom) in neuradno podporo za npr VMS.<ref>{{navedi splet|title=history [vmspython]|url=https://www.vmspython.org/doku.php?id=history|access-date=2020-12-04|website=www.vmspython.org|archive-date=2 December 2020|archive-url=https://web.archive.org/web/20201202194743/https://www.vmspython.org/doku.php?id=history|url-status=live}}</ref> Prenosljivost platforme je bila ena njegovih prvih prioritet, v časovnem okviru Python 1 in 2 sta bila podprta celo OS/2 in Solaris; podpora je od takrat opuščena za številne platforme.<ref>{{navedi splet|title=Download Python for Other Platforms|url=https://www.python.org/download/other/|access-date=2020-12-04|website=Python.org|language=en|archive-date=27 November 2020|archive-url=https://web.archive.org/web/20201127015815/https://www.python.org/download/other/|url-status=live}}</ref>

==Generatorji dokumentacije API==
Orodja, ki lahko ustvarijo dokumentacijo za Python [[API]], so med drugim pydoc (na voljo kot del standardne knjižnice), Sphinx, Pdoc in njegove vilice, Doxygen in Graphviz.<ref>{{navedi splet |title=Documentation Tools |url=https://wiki.python.org/moin/DocumentationTools |access-date=2021-03-22 |website=Python.org |language=en |archive-date=11 November 2020 |archive-url=https://web.archive.org/web/20201111173635/https://wiki.python.org/moin/DocumentationTools |url-status=live }}</ref>

== Zunanje povezave ==
* [http://www.python.org/ Python.org]
* https://www.djangoproject.com/
* 
* 

== Sklici ==
{{sklici|1}}
[[Kategorija:Skriptni jeziki]]
[[Kategorija:1990 v znanosti]]
[[Kategorija:Objektno orientirani programski jeziki]]
{{normativna kontrola}}
__VSILIKAZALOVSEBINE__