| 167 |   |  - Boolovi operatorji (True/False) | 
                      
                        | 168 |   |  - Primerjalni opearatorji (==, !=, <, >, >=, <=) | 
                      
                      
                        |   | 167 |  - Boolovi operatorji (not, and, or, is, ... ) | 
                      
                        |   | 168 |  - Primerjalni operaratorji (==, !=, <, >, >=, <=) | 
                      
            
                  
                          |   | 214 |  | 
                  
                          |   | 215 | == STRINGI == | 
                  
                          |   | 216 | Stringi so, skupek znakov ujeti med enojne ali dvojne narekovaje. | 
                  
                          |   | 217 |  | 
                  
                          |   | 218 | === Združevanje stringov === | 
                  
                          |   | 219 | V angleščini, združevanje stringov z operatorjem "+" imenujemo "concatenation". | 
                  
                          |   | 220 | {{{ | 
                  
                          |   | 221 | #!python | 
                  
                          |   | 222 | hello = "Hello" | 
                  
                          |   | 223 | world = 'World' | 
                  
                          |   | 224 |  | 
                  
                          |   | 225 | hello_world = hello + ' ' + world | 
                  
                          |   | 226 | print(hello_world) | 
                  
                          |   | 227 | }}} | 
                  
                          |   | 228 |  | 
                  
                          |   | 229 | === Multiplikacija stringov === | 
                  
                          |   | 230 | Python pozna množenje stringov s številom. na tak način multipliciramo string poljubno-krat. | 
                  
                          |   | 231 | {{{ | 
                  
                          |   | 232 | #!python | 
                  
                          |   | 233 | hello = "hello" | 
                  
                          |   | 234 | ten_of_hellos = hello * 10 | 
                  
                          |   | 235 | print(ten_of_hellos) | 
                  
                          |   | 236 | }}} | 
                  
                          |   | 237 |  | 
                  
                          |   | 238 | === Indeksiranje stringov === | 
                  
                          |   | 239 | Do nekega poljubnega znaka stringa lahko dostopamo, če poznamo pozicijo tega znaka v stringu. To bomo pokazali na naslednjem primeru. Pri tem moramo biti pozorni na to, da Python šteje on 0 naprej ! | 
                  
                          |   | 240 | {{{ | 
                  
                          |   | 241 | #!python | 
                  
                          |   | 242 | python = "Python" | 
                  
                          |   | 243 | print("h " + python[3])     # Opomba: indeksiranje stringa se prične z 0 | 
                  
                          |   | 244 |  | 
                  
                          |   | 245 | p_crka = python[0] | 
                  
                          |   | 246 | print(p_crka) | 
                  
                          |   | 247 | }}} | 
                  
                          |   | 248 |  | 
                  
                          |   | 249 | V primeru (zelo) dolgih stringov se velikokrat izkaže za uporabno tako imenovano NEGATIVNO INDEKSIRANJE. Na tak način lahko štejemo pozicije znakov od konca striga proti začetku. | 
                  
                          |   | 250 | {{{ | 
                  
                          |   | 251 | #!python | 
                  
                          |   | 252 | dolg_string = "This is a very long string!" | 
                  
                          |   | 253 | klicaj = long_string[-1] | 
                  
                          |   | 254 | print(klicaj) | 
                  
                          |   | 255 | }}} | 
                  
                          |   | 256 |  | 
                  
                          |   | 257 | === Rezanje stringa (ang. "slicing") === | 
                  
                          |   | 258 | Rezanje strnga uporabljamo zato, da bi iz stringa dobili poljubni skupek znakov. Sintaksa rezanja je podobna tisti od indeksiranja. | 
                  
                          |   | 259 | {{{ | 
                  
                          |   | 260 | #!python | 
                  
                          |   | 261 | x = "Monty Python" | 
                  
                          |   | 262 | monty = x[:5]      # ta zapis je enak x[0:5]. Torej, tako 1., kot tudi 2. indeks lahko izpustimo | 
                  
                          |   | 263 | print(monty) | 
                  
                          |   | 264 |  | 
                  
                          |   | 265 | python = x[6:] | 
                  
                          |   | 266 | print(python) | 
                  
                          |   | 267 | }}}  | 
                  
                          |   | 268 |  | 
                  
                          |   | 269 | === "in" operator === | 
                  
                          |   | 270 | Da bila lahko preverili, če neki string vsebuje specifični znak/črko/podstring uporabljamo omenjeni operator. | 
                  
                          |   | 271 | {{{ | 
                  
                          |   | 272 | #!python | 
                  
                          |   | 273 | x = "ime spremenljivke" | 
                  
                          |   | 274 | print("ime" in x) # Izpise direktno boolovo vrednost izraza | 
                  
                          |   | 275 |  | 
                  
                          |   | 276 | y = "spremenljivke" in x | 
                  
                          |   | 277 | print(y) | 
                  
                          |   | 278 | }}} | 
                  
                          |   | 279 |  | 
                  
                          |   | 280 | === Funkcija "len()" === | 
                  
                          |   | 281 | Funcijo len() uporabljamo, da bi ugotovili koliko znakov poljubni string vsebuje. | 
                  
                          |   | 282 | {{{ | 
                  
                          |   | 283 | #!python | 
                  
                          |   | 284 | # -*- coding: utf-8 -*- | 
                  
                          |   | 285 | # Izpis prve polovice stringa x  | 
                  
                          |   | 286 |  | 
                  
                          |   | 287 | x = ''' | 
                  
                          |   | 288 | To je zelo dolg string, | 
                  
                          |   | 289 | katerega omejujejo trojni | 
                  
                          |   | 290 | narekovaji | 
                  
                          |   | 291 | ''' | 
                  
                          |   | 292 |  | 
                  
                          |   | 293 | print(x[int(len(x)/2)]) # Opomba: Ugotovite zakaj je bilo v tem primeru uporabiti funkcijo int() in pa kako še bi lahko | 
                  
                          |   | 294 |                         # prišli do istega rezultata brez funcije int() ? | 
                  
                          |   | 295 | }}} | 
                  
                          |   | 296 |  | 
                  
                          |   | 297 | === Izničevanje prvotne funcije narekovajev === | 
                  
                          |   | 298 | Z znakom "\" (backslash) lahko narekovaje uporabimo le kot neki znak, kjer nas njihova funkcija, da definirajo string ne "omejuje" več. | 
                  
                          |   | 299 | {{{ | 
                  
                          |   | 300 | #!python | 
                  
                          |   | 301 | print('The name of this ice-cream is "Sweeet\'n\'Tasty"') | 
                  
                          |   | 302 | }}} | 
                  
                          |   | 303 |  | 
                  
                          |   | 304 | === Osnovne metode s stringi === | 
                  
                          |   | 305 | Python ima številne funkcije za operiranje s tringi. Te funcije so shranjene v knjižnici stringa. Vse te funcije so ŽE vgrajene v vsak string. Te funcije oz. včasih znane tudi kot metode (ker so funcije definirane v razredi. Več o tem kasneje) lahko uporabimo tako, da spremenljivki stringa dodamo "." in nato še metodo. Do vseh možnih metod lahko v PyCharmu dostopamo tako, da se postavimo za "." in izvedemo ukaz "Ctrl" + "Space". Sicer nam vse te možnosti PYCharm večinom že sproti prikazuje. | 
                  
                          |   | 306 | Mogoče je smotrno omeniti še to, da vse te funcije osnovnega stringa NE SPREMENIJO, temveč le vrnejo NOV string, kateri je bil modoficiran. | 
                  
                          |   | 307 | {{{ | 
                  
                          |   | 308 | #!python | 
                  
                          |   | 309 | # -*- coding: utf-8 -*- | 
                  
                          |   | 310 | monty_python = "Monty Python" | 
                  
                          |   | 311 | print(monty_python) | 
                  
                          |   | 312 |  | 
                  
                          |   | 313 | print(monty_python.upper())    # Primer, kako lahko osnovni string  | 
                  
                          |   | 314 |                                # zapišemo z velikimi črkami | 
                  
                          |   | 315 | print(monty_python[3].lower())  | 
                  
                          |   | 316 | }}} | 
                  
                          |   | 317 |  | 
                  
                          |   | 318 | === Formatiranje stringa === | 
                  
                          |   | 319 | Da bi lahko združevali string s spremenljivkami oz. njihovimi vrednostmi uporabljamo "%" operator (v ang. "modulo" operator). | 
                  
                          |   | 320 | {{{ | 
                  
                          |   | 321 | #!python | 
                  
                          |   | 322 | x = 8 | 
                  
                          |   | 323 | y = 8.77 | 
                  
                          |   | 324 | ime = "Andrej" | 
                  
                          |   | 325 | print("%s ima %d let. Danes se je v soli \nucil o decimalnih stevilih in je izracunal,\nda ima na danasnji dan natanko %.3f let." % (ime, x, y)) | 
                  
                          |   | 326 | }}} |