b'\n_START_ARTICLE_\nPython (programski jezik)\n_START_SECTION_\nProgram \'Pozdravljen svet\'\n_START_PARAGRAPH_\n# Ta program izpi\xc5\xa1e besedilo \'Pozdravljen svet\'.print("Pozdravljen svet")_NEWLINE_V pythonu se tip niz (string) ozna\xc4\x8duje z "". Funkcija print se uporablja za izpis podatkov, medtem ko izjava return vrne vrednost nekega objekta. V pythonu obstajata dva tipa komentarjev: #, ki se uporablja za enovrsti\xc4\x8dne komentarje in """ """ docstring ali ve\xc4\x8dvrsti\xc4\x8dni komentar. Obe vrsti komentarjev sta ignorirani med izvajanjem programa.\n_START_SECTION_\nSpremenljivke\n_START_PARAGRAPH_\nSpremenljivke se v pythonu definirajo tako da jih preprosto napi\xc5\xa1emo in jim dodelimo vrednost. Nato se same specializirajo v podatkovne tipe, ve\xc4\x8dina spremenljivk na\xc5\xa1tetih spodaj spadajo pod primitivne podatkovne tipe._NEWLINE_pozdrav = "\xc5\xbdivjo"   # niz (string)denar = 100         # celo \xc5\xa1tevilo (integer)povpre\xc4\x8dje = 12.699  # decimalno \xc5\xa1tevilo (float)jeVesel = True      # boolean (True ali False)komplekso_stevilo = 2+5j       # kompleksno \xc5\xa1tevilo (complex)_NEWLINE_Da preverimo vrsto nekega podatka uporabimo klju\xc4\x8dno besedo type. _NEWLINE_print(type(pozdrav))print(type(denar))print(type(povpre\xc4\x8dje))print(type(jeVesel))print(type(ena\xc4\x8dba))# izpis konzole<type \'str\'><type \'int\'><type \'float\'><type \'bool\'><type \'complex\'>_NEWLINE_Z spremenljivkami lahko tudi upravljamo tipe po lastnostih. Na primer:_NEWLINE_x = "Danes je obla\xc4\x8dno"print(x[3]) # izpi\xc5\xa1e \xc4\x8drko "e" saj Python za\xc4\x8dne vedno \xc5\xa1teti z 0.print(x[5:]) # izpi\xc5\xa1e " je obla\xc4\x8dno" saj izre\xc5\xbee vse pred 5 (\xc5\xa1teje se tudi presledek)print(x[:4]) # izpi\xc5\xa1e "obla\xc4\x8dno" saj izre\xc5\xbee vse po 4.print(len(x)) # izpi\xc5\xa1e dol\xc5\xbeino besede shranjene v spremenljivki x. Izpi\xc5\xa1e \'16\'.print(x[:-3]) # izpi\xc5\xa1e "a" saj kadar uporabimo znak minus (-), za\xc4\x8dne \xc5\xa1teti od desne proti levi.\n_START_SECTION_\nKonkatinacija in formatiranje niznega (string) tipa\n_START_PARAGRAPH_\nKonkatinacija se uporablja kadar moramo zdru\xc5\xbeiti ve\xc4\x8d manj\xc5\xa1ih niznih (string) objektov v kon\xc4\x8dni izpis. Pri tem se uporablja operator +. \xc4\x8ce ho\xc4\x8demo konkatinirati druge podatkovne tipe jih moramo najprej prevesti v niz (string)._NEWLINE_x = "Pozdravljen"y = "svet"print(x + " " + y)# izpis konzolePozdravljen svet# primer prevoda podatkovnega tipaje\xc5\xbdalosten = FalsekolikoLet = 100000je\xc5\xbdalosten = str(je\xc5\xbdalosten)kolikoLet = str(kolikoLet)print("Ali si \xc5\xbealosten: " + je\xc5\xbdalosten)print("Koliko let ima\xc5\xa1: " + kolikoLet)# izpis konzoleAli si \xc5\xbealosten: FalseKoliko let ima\xc5\xa1: 100000_NEWLINE_Pri formatiranju se lahko uporabi kateri koli tip. Zato je formatiranje ve\xc4\x8dkrat uporabljeno._NEWLINE_x = 5y = "Jure"k = "Nina"e = 2+3o# prvi primerprint(y + " je vesel, saj je dobil oceno {}".format(x))# ali pa uporabimo znak %print(y + " je vesel, saj je dobil oceno %d"%x)# drugi primerprint("{0} in {1} sta skupaj re\xc5\xa1ila ena\xc4\x8dbo {2}".format(y, k, e))# V tem primeru funkcija \'format\' spremeni vrednost vseh y, k, e vrednosti v niz. Vpi\xc5\xa1e jih v glavni niz objekt po vrsti z za\xc4\x8detkom od 0 do 2\n_START_SECTION_\nMatematika\n_START_PARAGRAPH_\nMatematika v pythonu je zelo podobna kot v programskem jeziku C. Pozna 6 osnovnih operacij._NEWLINE_1 + 4  # se\xc5\xa1tevanje2 - 3  # od\xc5\xa1tevanje 6 * 2  # mno\xc5\xbeenje5 / 4  # deljenje (natan\xc4\x8dno)5 // 4 # deljenje (nenatan\xc4\x8dno)9 ** 9 # potenciranje43 % 3 # modulo """ Vse ra\xc4\x8dune lahko shranjujemo v spremenljivke """x = 2 + 5 # shrani rezultat ra\xc4\x8duna v xprint(x) # izpi\xc5\xa1e x_NEWLINE_Python ima vgrajeno ra\xc4\x8dunalo tako da ni potrebno uporabljati funkcije print, z izjemo \xc4\x8de razvijamo v IDE.\n_START_SECTION_\nLogi\xc4\x8dni operatorji\n_START_PARAGRAPH_\nV python-u poznamo 5 osnovnih logi\xc4\x8dnih operatorjev. Logi\xc4\x8dni operatorji vedno vrnejo vrednost True ali False._NEWLINE_4 < 2 # manj\xc5\xa1e od3 > 2 # ve\xc4\x8dje od6 <= 0 # manj\xc5\xa1e ali enako od3 >= 1 # ve\xc4\x8dje ali enako od8 == 3 # enako7 != 5 # ni enako# spet se lahko vse shranjuje v spremenljivkex = 3 < 4print(x)# izpi\xc5\xa1e True, saj je 3 manj\xc5\xa1e od 4_NEWLINE_\xc4\x8ce ho\xc4\x8demo primerjati vrednosti z razli\xc4\x8dnimi \xc5\xbeeljami moramo uporabiti posebne izjave s klju\xc4\x8dnimi besedami \'and\', \'or\', \'not\' in \'is\'._NEWLINE_and # pri katerem morajo za skupno vrednost True vse vrednosti vrniti True, sicer vrne False.or  # pri katerem mora vsaj ena od vrednosti vrniti True da skupno velja tudi True, druga\xc4\x8de False.not # not True vrne False, medtem ko not False vrne True. Podobno operatorju !=is  # podobn operatorju ==3 < 4 and 2 > 1# izpis True # saj sta obe vrednosti pravilni3 > 2 or 6 < 2 # saj je ena od vrednosti pravilnaTrue3 == 3 and not 2 >= 9 _NEWLINE_True # saj je pred desno vrednostjo not""" Vse to se lahko shrani v spremenljivke """\n_START_SECTION_\nKolektivni podatkovni tipi\n_START_PARAGRAPH_\nPython pozna nekaj kolektivnih podatkovnih tipov. Te tipi vsebujejo ve\xc4\x8d podatko za razliko od spremenljivk. Poznamo list, tuple, dict in set_NEWLINE_znamke = ["Ferrari", "BMW", "Honda", "Alfa"] # to je list z 4 vrednostmi enakega tipa podatkovvse = (0, "Vito", 44, True, None, "\xc5\xbdivjo", 2.44) # to je tuple, ki lahko vsebuje katerikoli tip podatkatabela_ocen = {"Miha":4, "Jure":2, "Jaz":5, "Nekdo":1, "Maja":4, "Nina":3} """ to je dictionary 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\xc5\xa1emo s print funkcijoprint(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, \'\xc5\xbdivjo\', 2.44){\'Miha\':4, \'Jure\':2, \'Jaz\':5, \'Nekdo\':1, \'Maja\':4, \'Nina\':3}<type \'list\'><type \'tuple\'><type \'dict\'>_NEWLINE_Urejanje kolektivnih podatkovnih tipov_NEWLINE_\xc4\x8ce ho\xc4\x8demo dobiti dolo\xc4\x8den podatek v nekem kolektivnem podatkovnem tipu naredimo to:_NEWLINE_x = ["A", "B", "C", "D"]print(x[2])# konzola izpi\xc5\xa1e C saj se list za\xc4\x8dne \xc5\xa1teti z 0# da dodamo vrednost listu uporabimo metodo appendx.append("E") # to doda x listu na konec vrednost "E"# da odstranimo vrednost listu uporabimo metodo popx.pop(1) # izbri\xc5\xa1e drugo vrednost na listu v tem primeru "B"print(x)# konzola izpi\xc5\xa1e [\'A\', \'C\', \'D\', \'E\']# \xc4\x8de nevemo katero \xc5\xa1tevilo pripada dolo\xc4\x8deni vrednosti na listu uporabimo metodo count\xc5\xa1t_a = x.count("A")print(\xc5\xa1t_a) # izpi\xc5\xa1e 0 saj je a na prvem mestu._NEWLINE_Za vsak kolektivni podatek obstaja vsaj 5 metod.\n_START_SECTION_\nVnos\n_START_PARAGRAPH_\nVnos se izra\xc5\xbea z 2 built-in keyword-oma input in raw_input. \xc4\x8ce uporabimo raw_input potem se vsak na\xc5\xa1 vnos \xc5\xa1teje kot string, \xc4\x8de pa uporabljamo input moramo pred njega vstaviti tip podatka katerega ho\xc4\x8demo pridobiti na primer: int(input("Vnesi \xc5\xa1tevilo: ")), za vnos \xc5\xa1tevila. raw_input ni ve\xc4\x8d v uporabi od python verzije 3.6.x _NEWLINE_# primer raw_input keywordax = raw_input("Vnesi svoje ime: ")print("Pozdravljen " + x + "!")print("Dol\xc5\xbeina tvojega imena je {}".format(len(x)))  # len() keyword se uporablja pri ugotavljanju dol\xc5\xbeine dolo\xc4\x8dene besede# primer input keyworday = raw_input("Vnesi svoje ime: ")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.\n_START_SECTION_\nPogojni stavki in nested zanke\n_START_PARAGRAPH_\nPogojni stavki se uporabljajo predvsem za zastavljanje pogojev skozi katere mora neka vrednost priti, da se nekaj izvaja. Izra\xc5\xbea se jih s keyword-i if, elif in else. Nested zanka pomeni prakti\xc4\x8dno zanka v zanki oziroma ve\xc4\x8d pogojev v pogoju._NEWLINE_# primer if-elif-else stavkabarva = raw_input("Vnesi svojo najljub\xc5\xa1o barvo: ")if barva == "rde\xc4\x8da" or "modra":_NEWLINE_   print("Zelo lepo")elif barva == "zelena" or "rumena":_NEWLINE_   print("Lepo")elif barva == "\xc4\x8drna" or "bela" or "roza":_NEWLINE_   print("Ne najbolje")elif barva == "rjava" or "oran\xc5\xbena" or "lila":_NEWLINE_   print("Slaba izbira")else:_NEWLINE_   print("python pravi: ne poznam te barve")# primer if-else stavkas = int(input("Prosim vnesi svojo starost: "))if s < 18:_NEWLINE_   print("Dostop ni dovoljen.")else:_NEWLINE_   print("Dobrodo\xc5\xa1li")# matemati\xc4\x8dni primer if 9 + 1 == 10:_NEWLINE_   print("Pravilno")elif 9 + 1 != 10:_NEWLINE_   print("Narobe")_NEWLINE_# primer nested stavkac = raw_input("Vnesi \xc4\x8drko: ")k = int(input("Vnesi \xc5\xa1tevilko: ")if c in [\'A\',\'B\',\'C\',\'D\',\'E\',\'F\']:_NEWLINE_   if k > 50:_NEWLINE_      print("Uspe\xc5\xa1no")_NEWLINE_   elif k <= 40:_NEWLINE_      print("Skoraj uspe\xc5\xa1no")_NEWLINE_   else:_NEWLINE_      print("Ni uspe\xc5\xa1no")elif c in [\'K\',\'L\',\'M\',\'N\',\'O\']:_NEWLINE_   print("Bravo zmagal si")elif len(c) < 1 and len(c) > 1:_NEWLINE_   print("Mora\xc5\xa1 vpisati samo eno \xc4\x8drko")else:_NEWLINE_   print("Napaka")\n_START_SECTION_\nfor in while stavka\n_START_PARAGRAPH_\nStavek for se uporablja da se izbere vse \xc4\x8dlane nekega kolektivnega podatkovnega tipa. Stavek while pa se uporablja kot pogoj dokler nekaj ne naredi uporabnik do takrat se bo while stavek izvajal._NEWLINE_# primer for stavkapozdravi = [\'\xc5\xbdivjo\', \'Zdravo\', \'Pozdravljeni\']for x in pozdravi:_NEWLINE_    print(x)# izpis konzole \xc5\xbdivoZdravoPozdravljeni# primer while stavlkap = "12345"while True:_NEWLINE_   r = raw_input("Vnesi geslo: ")_NEWLINE_   if r != p:_NEWLINE_      print("Napa\xc4\x8dno Geslo")_NEWLINE_   elif r == p:_NEWLINE_      print("Dobrodo\xc5\xa1li")# izpis konzoleVnesi geslo: 54321Napa\xc4\x8dno GesloVnesi geslo: 12345Dobrodo\xc5\xa1li\n_START_SECTION_\nModule\n_START_PARAGRAPH_\nVsak dokument z oznako .py ipd... in se shrani na lokalni napravi kot python modula katero lahko dodamo v kodo \xc4\x8de uporabimo izjavo import._NEWLINE_Pozdravi.py_NEWLINE_# sedaj pi\xc5\xa1em v Pozdravi.py datotekodef Re\xc4\x8di\xc5\xbdivjo(ime):_NEWLINE_    print("\xc5\xbdivjo "+ime)_NEWLINE_Glavni.py_NEWLINE_# sedaj pi\xc5\xa1em v Glavni.pyimport Pozdravi# ali pafrom Pozdravi import Re\xc4\x8di\xc5\xbdivjox = "Anastazija", "\xc5\xa0pela", "Marija"for w in x:_NEWLINE_    Re\xc4\x8di\xc5\xbdivjo(w)# izpis konzole\xc5\xbdivjo Anastazija\xc5\xbdivjo \xc5\xa0pela\xc5\xbdivjo Marija\n_START_SECTION_\nFunkcije\n_START_PARAGRAPH_\nFunkcije se uporablja zato da, se ne pi\xc5\xa1e dvojno in zato, da lahko nekaj naredijo. _NEWLINE_Funkcije lahko vrnejo dolo\xc4\x8deno vrednost ali pa se samo uporabijo, imajo parametre, \xc4\x8de se definirane v razredu se imenujejo metode._NEWLINE_Vedno jih za\xc4\x8dnemo s keyword def, razen v primeru neznane funkcije lambda._NEWLINE_def Se\xc5\xa1tej(x, y):_NEWLINE_    print("Rezultat = {}".format(x + y))Se\xc5\xa1tej(2, 4) # klic funkctije # izpis6_NEWLINE_# primer funkcije brez parametrovdef ZahtevajVpis():_NEWLINE_    uporabni\xc5\xa1ko_ime = raw_input("Vnesi uporabni\xc5\xa1ko ime: ")_NEWLINE_    geslo = raw_input("Vnesi geslo: ")_NEWLINE_    if len(geslo) < 6:_NEWLINE_       print("Geslo more vsebovati ve\xc4\x8d kot 6 znakov")_NEWLINE_    else:_NEWLINE_       print("Dobrodo\xc5\xa1el uporabnik {}".format(uporabni\xc5\xa1ko_ime))# primer funkcije z definiranimi parametridef Od\xc5\xa1tej3in4(x=3, y=4)_NEWLINE_    r = x - y_NEWLINE_    print(r)Od\xc5\xa1tej3in4()# izpis konzole -1_NEWLINE_Funkcijo lahko pokli\xc4\x8demo tudi v drugi funkciji saj so vse funkcije globalne. Z izjemo metod definiranih v UDR._NEWLINE_def Pozdravi(ime):_NEWLINE_    print("\xc5\xbdivjo "+ime)def Vpra\xc5\xa1anje():_NEWLINE_    i = raw_input("Vnesi ime: ")_NEWLINE_    Pozdravi(i)     _NEWLINE__NEWLINE_Vpra\xc5\xa1anje()# izpis konzole Vnesi ime: Nekdo\xc5\xbdivjo Nekdo_NEWLINE_Funkcija ima lahko tudi definirane tipe podatkov parametrov._NEWLINE_def Od\xc5\xa1tej(a:int, b:int):_NEWLINE_    print("{}".format(str(a + b))def PrepoznajTip(t:(list, dict), p:bool = True)_NEWLINE_    if p:_NEWLINE_       if type(t) == type(list):_NEWLINE_          print("Tip je list")_NEWLINE_       elif type(t) == type(dict):_NEWLINE_          print("Tip je dict")_NEWLINE_       else:_NEWLINE_          print("Tip ni prepoznan")_NEWLINE_ Primeri Funkcij _NEWLINE_import timedef \xc5\xa0tej(od, do, zamik=0.5):_NEWLINE_    while od < do:_NEWLINE_          od = od + 1_NEWLINE_          print(od)_NEWLINE_          time.sleep(zamik)def Vnos():_NEWLINE_    ime = raw_input("Vnesi ime: ")_NEWLINE_    priimek = raw_input("Vnesi priimek: ")_NEWLINE_    print("Pozdravljen "+ime+ " " +priimek)# tukaj se uporablja ti. nested funkcije pri kateri je lahko funkcija v funkcijidef Kalkulator():_NEWLINE_    def Se\xc5\xa1tej(x, y):_NEWLINE_        return x + y_NEWLINE__NEWLINE_    def Od\xc5\xa1tej(x, y):_NEWLINE_        return x - y_NEWLINE__NEWLINE_    def Mno\xc5\xbei(x, y):_NEWLINE_        return x * y_NEWLINE__NEWLINE_    def Deli(x, y):_NEWLINE_        return x / y_NEWLINE__NEWLINE_    def Potenciraj(x, y):_NEWLINE_        return x ** y_NEWLINE__NEWLINE_    def Moduliraj(x, y):_NEWLINE_        return x % y_NEWLINE_    _NEWLINE_    print("Izberi mo\xc5\xbenost")_NEWLINE_    print("Se\xc5\xa1tevanje = 1")_NEWLINE_    print("Od\xc5\xa1tevanje = 2")_NEWLINE_    print("Mno\xc5\xbeenje = 3")_NEWLINE_    print("Deljenje = 4")_NEWLINE_    print("Potenciranje = 5")_NEWLINE_    print("Moduliranje = 6")_NEWLINE_    o = raw_input("Izbira: ")_NEWLINE_    p = int(input("Prvi: ")_NEWLINE_    d = int(input("Drugi: ")_NEWLINE_    if o == "1":_NEWLINE_       Se\xc5\xa1tej(p, d)_NEWLINE_    elif o == "2":_NEWLINE_       Od\xc5\xa1tej(p, d)_NEWLINE_    elif o == "3":_NEWLINE_       Mno\xc5\xbei(p, d)_NEWLINE_    elif o == "4":_NEWLINE_       Deli(p, d)_NEWLINE_    elif o == "5":_NEWLINE_       Potenciraj(p, d)_NEWLINE_    elif o == "6":_NEWLINE_       Moduliraj(p, d)_NEWLINE_    else:_NEWLINE_       print("Neznana operacija.")Kalkulator()# izpis konzoleIzberi mo\xc5\xbenostSe\xc5\xa1tevanje = 1Od\xc5\xa1tevanje = 2Mno\xc5\xbeenje = 3Deljenje = 4Potenciranje = 5Moduliranje = 6Izbira: 2  # jaz napisal 2Prvi: 10Drugi: 4# izpis funkcije6\n_START_SECTION_\nRazredi\n_START_PARAGRAPH_\nRazredi lahko vsebujejo funkcije. Funkcije v razredu se imenujejo metode. Razrede se inicializira tako da dobimo novo instanco z __init__ predefinirano build-in funkcijo. Pod to globalno predifinicijo spadajo tudi __delattr__, __format__, __getattribute__, __hash__, __long__, __native__, __new__, __call__, __repr__, __nonzero__, __sizeof__, __setattr__, __unicode__, __str__ in drugi. Vsaka definicija od na\xc5\xa1tetih zgoraj ima svoj pomen._NEWLINE_# glavni razredclass A:_NEWLINE_    def __init__(self): # klic konstruktorja_NEWLINE_        print("Inicializeran razred A")# podrazredclass Z(A):_NEWLINE_    def __init__(self):_NEWLINE_        super(Z, self).__init__(A)  # klic superkonstruktorjaclass U(Z, A):_NEWLINE_    def __init__(self, m1, m2):_NEWLINE_        super(Z, U, A, self).__init__(m1, m2)  # klic superkonstruktorja s parametri# primer nelogi\xc4\x8dnega oziroma nepravilnega razredaclass B:_NEWLINE_    def __init__(self):_NEWLINE_        pass# novo definirane globalne spremenljivke v razedu BB.ime = "Tone"B.priimek = "Altgr"r = B.ime # objekte in njihove \xc4\x8dlane lahko shranjujemo v spremenljivkeprint(r)_NEWLINE_        _NEWLINE__NEWLINE_# primer razreda za osebeclass Oseba:_NEWLINE_    def __init__(self, ime:str, priimek:str, starost:int, email:str):_NEWLINE_        self.ime = ime # \xc4\x8de damo pred objek parameter self lahko dostopamo do njegovih atributov_NEWLINE_        self.priimek = priimek_NEWLINE_        self.starost = starost_NEWLINE_        self.email = email_NEWLINE__NEWLINE_        podatki = [[], []] # multidimenzionali list_NEWLINE_        podatki[0].append(ime)_NEWLINE_        podatki[0].append(priimek)_NEWLINE__NEWLINE_        podatki[1].append(starost)_NEWLINE_        podatki[1].append(email)_NEWLINE__NEWLINE_    def zahtevaj_podatke(self): # funkcija za klic izpisa podatkov na formatni na\xc4\x8din_NEWLINE_        print("Ime: {}".format(self.ime))_NEWLINE_        print("Priimek: {}".format(self.priimek))_NEWLINE_        print("Starost: {}".format(self.starost))_NEWLINE_        print("Email: {}".format(self.email)_NEWLINE__NEWLINE_    def zahtevaj_dimenzije(self):_NEWLINE_        print(podatki)Jaz = Oseba("Tit", "PError", 15, "tit.PError@unknown.abc") _NEWLINE_# Jaz postane Object Oseba z dolo\xc4\x8denimi \xc4\x8dlani npr. ime. ter metodami za interpretacijo objekta ali postaktivnost tega objekta oziroma njegovih \xc4\x8dlanov.Jaz.zahtevaj_podatke()# izpis konzole Ime: TitPriimek: PErrorStarost: 15Email: tit.PError@unknow.abc# ali print(Jaz.ime) # . pomeni \xc4\x8dlan nekega kolektiva v razredu.print(Jaz.priimek)print(Jaz.starost)print(Jaz.email)'