Python (programski jezik)

Python

Začetna izdaja	20. februar 1991
Oblikoval	Guido van Rossum
Razvijalec	Python Software Foundation in Guido van Rossum
Stabilna izdaja	3.12.3 in 3.13.0a6
Tipizacija	dinamično, močno, varno
Večje implementacije	CPython, IronPython, Jython, Python for S60, PyPy
Vplivi	ALGOL 68, ABC, Modula-3, C, C++, Perl, Java, Lisp, Haskell, APL, CLU, Dylan, Icon in Standard ML
Vplival na	Boo, Cobra, D, Falcon, Groovy, JavaScript, Ruby
OS	večplatformsko
Licenca	Python Software Foundation License
Spletna stran	https://www.python.org/
Python Programming na Wikibooks

Python je tolmačitveni programski jezik, ki ga je ustvaril Guido van Rossum leta 1990. Jezik je dobil ime po priljubljeni angleški televizijski nanizanki Leteči cirkus Montyja Pythona (Monthy Python's Flying Circus). Python ima popolnoma dinamične podatkovne tipe, samodejno upravlja s pomnilnikom in podpira funkcionalno, imperativno oziroma proceduralno, strukturirano in objektno orientirano računalniško programsko paradigmo. Zaradi dinamičnih podatkovnih tipov je podoben jezikom Perl, Ruby, Scheme, Smalltalk in Tcl. Razvili so ga kot odprtokodni projekt, ki ga je upravljala neprofitna organizacija Python Software Foundation. Python se v glavnem uporablja za računalniško analitiko in razvijanje internetnih aplikacij.

Python uporablja različna orodja za različne tipe razvijanja aplikacij, za Grafični Uporabniški Umesnik oziroma GUI ima vsaj tri različna orodja, ta orodja med najbolj pogostimi so: Kivy, PyQt, PySide, Pygame, PyForms, tkInter. Python ima tudi orodja za razvijanje internetnih aplikacij med najbolj pogosto uporabljena sodijo: 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 orodji je že nameščena, če uporabnik uporablja Integrirano Razvijalsko Okolje oziroma IDE. Python pa ima tudi orodja za analitiko in razvijalce programske opreme. Med najpogostege uporabljena orodja za analitiko spadajo: SciPy, Pandas in IPython. Za razvijanje programske opreme pa se uporabljajo predvsem naslednja orodja: Buildbot, Trac in Roundup. Uporabljajo se tudi orodja za skrbništvo sistema kot na primer: Ansible, Salt in OpenStack.

Program Pozdravljen svet

# Ta program izpiše pozdravljen svet.
print("Pozdravljen svet")

V python-u se tip string označuje z "". Funkcija print se uporablja za izpis podatkov medtem, ko izjava return vrne vrednost nekega objekta. V python-u obstajata dva tipa komentarjev #, ki se uporablja za enovrstične komentarje in """ """ docstring ali večvrstični komentar. Oba tipa komentarjev sta ignorirana med izvajanjem programa.

Spremenljivke

Spremenljivke se v pythonu definirajo tako da jih preprosto napišemo in jim dodelimo vrednost. Nato se same specializirajo v podatkovne tipe, večina spremenljivk naštetih spodaj spadajo pod primitivne podatkovne tipe.

pozdrav = "Živjo"   # tip string
denar = 100         # tip intiger
povprečje = 12.699  # tip float
jeVesel = True      # tip boolean 
komplekso_stevilo = 2+5j       # tip complex

Da preverimo tip nekega podatka uporabimo keyword type.

print(type(pozdrav))
print(type(denar))
print(type(povprečje))
print(type(jeVesel))
print(type(enačba))

# izpis konzole
<type 'str'>
<type 'int'>
<type 'float'>
<type 'bool'>
<type 'complex'>

Z spremenljivkami lahko tudi upravljamo tipe po lastnostih. Naprimer:

x = "Danes je oblačno"
print(x[3]) # izpiše črko "e" saj žačne šteti pri 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" sej izreže vse po 4.
print(len(x)) # izpiše dolžino besede shranjene v spremenljivki x. Začne šteti z 1.
print(x[:-3]) # izpiše "a" saj kadar uporabimo - šteje od desne proti levi.

Konkatinacija in formatiranje string tipa

Konkatinacija se uporablja kadar moramo združiti več majhnih string objektov v končni izpis. Pri tem se uporablja operator +. Če hočemo konkatinirati druge podatkovne tipe jih moramo prvo prevesti v string.

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

Pri formatiranju se lahko uporabi kateri koli tip. Zato je formatiranje večkrat uporabljeno.

x = 5
y = "Jure"
k = "Nina"
e = 2+3o

# prvi primer
print(y + " je vesel, saj je dobil oceno {}".format(x))

# ali pa uporabimo znak %
print(y + " je vesel, saj je dobil oceno %d"%x)

# drugi primer
print("{0} in {1} sta skupaj rešila enačbo {2}".format(y, k, e))
# v tem primeru format funkcija spremeni vrednost vseh y, k, e vrednosti v string. Ter jih vpiše v glavni string objek po vrsti z začetkom 0 do 2

Matematika

Matematika v python-u je zelo podobna kot v programskem jeziku C. Pozna 6 osnovnih operacij.

1 + 4  # seštevanje
2 - 3  # odštevanje 
6 * 2  # množenje
5 / 4  # deljenje (natančno)
5 // 4 # deljenje (nenatančno)
9 ** 9 # potenciranje
43 % 3 # modulo 

""" Vse račune lahko shranjujemo v spremenljivke """
x = 2 + 5 # shrani rezultat računa v x
print(x) # izpiše x

Python ima vgrajeno računalo tako da ni potrebno uporabljati funkcije print, z izjemo če razvijamo v IDE.

Logični operatorji

V python-u poznamo 5 osnovnih logičnih operatorjev. Logični operatoji vedno vrnejo vrednost True ali False.

4 < 2 # manjše od
3 > 2 # večje od
6 <= 0 # manjše ali enako od
3 >= 1 # večje ali enako od
8 == 3 # enako
7 != 5 # ni enako

# spet se lahko vse shranjuje v spremenljivke
x = 3 < 4
print(x)
# izpiše True saj je 3 manjše od 4

Če hočemo primerjati vrednosti z različnimi željami moramo uporabiti posebne keyword izjave.

and # pri katerem morajo vse vrednosti vrniti True da vrne True drugače False.
or  # pri katerem mora ena od vrednosti vrniti True da vrne True drugače 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 pravilni

3 > 2 or 6 < 2 # saj je ena od vrednosti pravilna
True

3 == 3 and not 2 >= 9 
True # saj je pred desno vrednostjo not

""" Vse to se lahko shrani v spremenljivke """

Kolektivni podatkovni tipi

Python pozna nekaj kolektivnih podatkovnih tipov. Te tipi vsebujejo več podatko za razliko od spremenljivk. Poznamo list, tuple, dict in set

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 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š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'>

Urejanje kolektivnih podatkovnih tipov

Če hočemo dobiti določen podatek v nekem kolektivnem podatkovnem tipu naredimo to:

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.

Za vsak kolektivni podatek obstaja vsaj 5 metod.

Vnos

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

# 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 = 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.

Pogojni stavki in nested zanke

Pogojni stavki se uporabljajo predvsem za zastavljanje pogojev skozi katere mora neka vrednost priti, da se nekaj izvaja. Izraža se jih s keyword-i if, elif in else. Nested zanka pomeni praktično zanka v zanki oziroma več pogojev v pogoju.

# primer if-elif-else stavka
barva = raw_input("Vnesi svojo najljubšo barvo: ")
if barva == "rdeča" or "modra":
   print("Zelo lepo")
elif barva == "zelena" or "rumena":
   print("Lepo")
elif barva == "črna" or "bela" or "roza":
   print("Ne najbolje")
elif barva == "rjava" or "oranžna" or "lila":
   print("Slaba izbira")
else:
   print("python pravi: 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")

# primer nested stavka
c = raw_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")

kkk目標kkk

Module

Vsak dokument z oznako .py ipd... in se shrani na lokalni napravi kot python modula katero lahko dodamo v kodo če uporabimo izjavo import.

Pozdravi.py

# sedaj pišem v Pozdravi.py datoteko
def RečiŽivjo(ime):
    print("Živjo "+ime)

Glavni.py

# sedaj pišem v Glavni.py
import Pozdravi
# ali pa
from Pozdravi import RečiŽivjo
x = "Anastazija", "Špela", "Marija"
for w in x:
    RečiŽivjo(w)

# izpis konzole
Živjo Anastazija
Živjo Špela
Živjo Marija

Funkcije

Funkcije se uporabla zato da, se ne piše dvojno in zato, da lahko nekaj naredijo. Funkcije lahko vrenjo določeno vrednost ali pa se samo uporabijo, imajo parametre, če se definirane v razredu se imenujejo metode. Vedno jih začnemo s keyword def, razen v primeru neznane funkcije lambda.

def Seštej(x, y):
    print("Rezultat = {}".format(x + y))

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

# primer funkcije brez parametrov
def ZahtevajVpis():
    uporabniško_ime = raw_input("Vnesi uporabniško ime: ")
    geslo = raw_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 z definiranimi parametri
def Odštej3in4(x=3, y=4)
    r = x - y
    print(r)

Odštej3in4()

# izpis konzole 
-1

Funkcijo lahko pokličemo tudi v drugi funkciji saj so vse funkcije globalne. Z izjemo metod definiranih v UDR.

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

Funkcija ima lahko tudi definirane tipe podatkov parametrov.

def Odštej(a:int, b:int):
    print("{}".format(str(a + b))

def PrepoznajTip(t:(list, dict), p:bool = True)
    if p:
       if type(t) == type(list):
          print("Tip je list")
       elif type(t) == type(dict):
          print("Tip je dict")
       else:
          print("Tip ni prepoznan")

Primeri Funkcij

import time
def Štej(od, do, zamik=0.5):
    while od < do:
          od = od + 1
          print(od)
          time.sleep(zamik)

def Vnos():
    ime = raw_input("Vnesi ime: ")
    priimek = raw_input("Vnesi priimek: ")
    print("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 = raw_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

Razredi

Razredi 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štetih zgoraj ima svoj pomen.

# 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("Tit", "PError", 15, "tit.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: Tit
Priimek: PError
Starost: 15
Email: tit.PError@unknow.abc

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

Zunanje povezave

• Python.org