U ovom članku ćemo govoriti o čistom kodu — njegovim prednostima, različitim standardima i principima koda, kao i opštim smernicama o tome kako pisati čist kod.

Šta je čist kod? Čist kod je skup pravila i principa koji pomažu da se naš kod održi čitljivim, održivim i proširivim. To je jedan od najvažnijih aspekata pisanja kvalitetnog softvera.

Mi (programeri) provodimo mnogo više vremena čitajući kod nego što ga zapravo pišemo, zbog čega je važno da pišemo dobar kod.

Pisanje koda je lako, ali pisanje dobrog, čistog koda je teško.

Čist kod koji pišemo treba da bude jednostavan, izražajan i bez suvišnih duplikata. Izražajan kod znači da, iako samo dajemo instrukcije računaru, treba da bude čitljiv i jasno prenosi svoju nameru kada ga čitaju ljudi.

Važnost čistog koda Pisanje čistog koda ima brojne prednosti. Na primer, čist kod je: lako razumljiv efikasan lakši za održavanje, skaliranje, debagovanje i refaktoriranje Takođe obično zahteva manje dokumentacije.

Standardi koda

-su kolekcije pravila kodiranja, smernica i najboljih praksi. Svaki programski jezik dolazi sa svojim standardima kodiranja, koje treba slediti kako biste pisali čistiji kod. Obično pokrivaju: organizaciju fajlova praksa programiranja i principi formatiranje koda (uvlačenja, deklaracije, izjave) konvencije o imenovanju komentari PEP 8 (Python Enhancement Proposal) PEP 8 je vodič za stil koji opisuje standarde kodiranja za Python. To je najpopularniji vodič u Python zajednici. Najvažnija pravila navode sledeće:

PEP 8 konvencije o imenovanju:

Imena klasa treba da budu u CamelCase formatu (MyClass) imena promenljivih treba da budu u snake_case formatu i sve mala slova (first_name) imena funkcija treba da budu u snake_case formatu i sve mala slova (quick_sort()) konstante treba da budu u snake_case formatu i sve velika slova (PI = 3.14159) moduli treba da imaju kratka imena u snake_case formatu i sve mala slova (numpy) jednaki navodnici i dvostruki navodnici se tretiraju isto (samo odaberite jedan i budite dosledni) PEP 8

Formatiranje linija:

Uvlačenje treba da bude 4 razmaka (razmaci su preferirani u odnosu na tabove) linije ne bi trebalo da budu duže od 79 karaktera izbegavajte više izjava u istoj liniji top-level funkcije i definicije klasa su okružene sa dve prazne linije definicije metoda unutar klase su okružene jednom praznom linijom uvozi treba da budu u zasebnim linijama PEP 8

Prazna mesta:

Izbegavajte dodatne razmake unutar zagrada ili vitica izbegavajte prazne razmake bilo gde uvek okružite binarne operatore sa jednim razmakom s obe strane ako se koriste operatori različitih prioriteta, razmislite o dodavanju praznog mesta oko operatora sa najnižim prioritom ne koristite razmake oko znaka = kada se koristi za navođenje ključnog argumenta PEP 8

Komentari:

Komentari ne bi trebalo da budu u suprotnosti sa kodom komentari bi trebalo da budu potpune rečenice komentari bi trebalo da imaju razmak nakon znaka # i prva reč treba da bude napisana velikim slovom višelinijski komentari korišćeni u funkcijama (docstrings) treba da imaju kratki opis jedne linije, a zatim više teksta Ako želite da saznate više, pročitajte zvaničnu referencu PEP 8.

Pythoničan kod Pythoničan kod je skup idioma, usvojenih od strane Python zajednice. To jednostavno znači da dobro koristite idiome i paradigme Python-a kako biste svoj kod učinili čistijim, čitljivijim i visoko performansnim.

Pythoničan čist kod uključuje:

Trikove sa promenljivama manipulaciju listama (inicijalizacija, sečenje) rad sa funkcijama eksplicitni kod Postoji velika razlika između pisanja Python koda i pisanja pythoničan kod. Da biste napisali pythoničan kod, ne možete jednostavno idiomatski prevoditi drugi jezik (poput Jave ili C++), morate da razmišljate na python način.

Pogledajmo primer. Moramo sabrati prvih 10 brojeva zajedno, kao što je 1 + 2 + … + 10.

Nepythonično rešenje bi izgledalo ovako:

n = 10 sum_all = 0

for i in range(1, n + 1): sum_all = sum_all + i

print(sum_all) # 55 Pythoničnije rešenje bi moglo izgledati ovako:

n = 10 sum_all = sum(range(1, n + 1))

print(sum_all) # 55 Ovaj drugi primer je mnogo lakši za čitanje iskusnom Python programeru, ali zahteva dublje razumevanje Pythonovih ugrađenih funkcija i sintakse. Najlakši način da pišete pythoničan kod je da imate Zen Python-a na umu dok pišete kod i da postepeno učite Pythonovu standardnu biblioteku.

Zen Python-a Zen Python-a je kolekcija od 19 „vodećih principa“ za pisanje kompjuterskih programa u Python-u. Kolekciju je napisao softverski inženjer Tim Peters 1999. godine. Uključena je kao uskršnje jaje u Python interpreter.

Možete je videti tako što ćete izvršiti sledeću komandu:

import this

import this

Zen Python-a, napisao Tim Peters

Lepo je bolje od ružnog. Eksplicitno je bolje od implicitnog. Jednostavno je bolje od složenog. Složeno je bolje od komplikovanog. Ravno je bolje od ugnježdenog. Retko je bolje od gustog. Čitljivost je važna.

Specijalni slučajevi nisu dovoljno posebni da bi se prekršila pravila. Iako praksa pobjeđuje čistotu. Greške nikada ne bi trebale proći tiho. Osim ako nisu eksplicitno utišane. U slučaju nejasnoće, odbijte iskušenje da pogađate. Trebao bi postojati jedan — i po mogućnosti samo jedan — očigledan način da se to učini. Iako taj način možda neće biti očigledan na prvi pogled osim ako niste Holanđanin.

Sada je bolje od nikada. Iako je nikad često bolje nego odmah sada. Ako je implementaciju teško objasniti, to je loša ideja. Ako je implementaciju lako objasniti, to može biti dobra ideja. Prostor imena su sjajna ideja — hajde da radimo više takvih stvari! Ako ste radoznali u vezi značenja „pesme“, pogledajte Zen Python-a, Objašnjeno, koji pruža liniju po liniju objašnjenje.

Principi koda Postoje brojni principi kodiranja koje možete pratiti kako biste napisali bolji kod, svaki sa svojim prednostima i nedostacima i kompromisima. Ovaj članak pokriva četiri popularnija principa: DRY, KISS, SoC i SOLID.

DRY (Ne ponavljaj se) Svaki deo znanja mora imati jedinstvenu, nedvosmislenu, autoritativnu reprezentaciju unutar sistema.

Ovo je jedan od najjednostavnijih principa kodiranja. Njegovo jedino pravilo je da kod ne bi trebalo da bude duplikat. Umesto da duplicirate linije, pronađite algoritam koji koristi iteraciju. DRY kod se lako održava. Ovaj princip možete odvesti još dalje pomoću modela/abstrakcije podataka.

Nedostaci DRY principa su da možete završiti sa previše apstrakcija, stvaranjem spoljnih zavisnosti i složenim kodom. DRY takođe može izazvati komplikacije ako pokušate promeniti veći deo vaše kodne baze. Zato treba izbegavati DRY u vašem kodu previše rano. Uvek je bolje imati nekoliko ponovljenih sekcija koda nego pogrešne apstrakcije.

KISS (Keep it simple, stupid) Većina sistema najbolje funkcioniše ako su održavani jednostavnim, umesto komplikovanim.

Princip KISS kaže da većina sistema najbolje funkcioniše ako se drže jednostavnim umesto komplikovanim. Jednostavnost bi trebala biti ključni cilj u dizajnu, a nepotrebnu složenost treba izbegavati.

SoC (Separation of concerns) SoC je dizajnerski princip za razdvajanje kompjuterskog programa u različite odeljke tako da svaki odeljak rešava poseban problem. Problem je skup informacija koji utiče na kod kompjuterskog programa.

Dobar primer SoC je MVC (Model – View – Controller).

Ako se odlučite za ovaj pristup, budite pažljivi da ne podelite vašu aplikaciju na previše modula. Trebalo bi da napravite novi modul samo kada to ima smisla. Više modula znači više problema.

SOLID SOLID je mnemonički akronim za pet dizajnerskih principa namijenjenih da učine dizajn softvera razumljivijim, fleksibilnijim i održivijim.

SOLID je izuzetno koristan prilikom pisanja OOP koda. Priča o podeli vašeg razreda u više podrazreda, nasleđivanju, apstrakciji, interfejsima i još mnogo toga.

Sastoji se od sledećih pet koncepata:

Princip jednog odgovornog ponašanja: „Klasa bi trebala imati jedan, i samo jedan, razlog za promenu.“ Princip otvoreno-zatvorenog: „Entiteti bi trebali biti otvoreni za proširenje, ali zatvoreni za promene.“ Princip Liskov substitution: „Funkcije koje koriste pokazivače ili reference na osnovne klase moraju biti sposobne koristiti objekte izvedenih klasa, a da to ne znaju.“

Princip segregacije interfejsa: „Klijent ne bi trebalo da bude prisiljen implementirati interfejs koji ne koristi.“ Princip inverzije zavisnosti: „Oslanjajte se na apstrakcije, a ne na konkretne stvari.“ Formatiranje koda Formatiranje koda primenjuje stil kodiranja kroz automatsko formatiranje i pomaže u postizanju i održavanju čistog koda. Većina njih vam omogućava da kreirate fajl za konfiguraciju stila koji možete deliti sa vašim kolegama.

Najpopularniji Python formatatori koda su:

black flake8 autopep8 yapf ruff Većina modernih IDE-a takođe uključuje lintere, koji rade u pozadini dok kucate i pomažu u identifikovanju malih grešaka u kodiranju, grešaka, opasnih obrazaca koda i održavaju vaš kod formatiranim. Postoje dve vrste linting-a: logički i stilistički.

Najpopularniji Python lint-eri su:

Pylint PyFlakes mypy Za više informacija o linting-u i formatiranju koda, pogledajte Python Code Quality.

Konvencije o imenovanju Jedan od najvažnijih aspekata pisanja čistog koda su konvencije o imenovanju. Uvek biste trebali koristiti smislena i namerna imena. Uvek je bolje koristiti duga, opisna imena nego kratka imena sa komentarima.

Ovo je loše

predstavlja broj aktivnih korisnika

au = 55

Ovo je dobro

broj_aktivnih_korisnika = 55 Pogledaćemo više primera u sledećim dvema sekcijama.

Promenljive

1. Koristite imenice za imena promenljivih
2. Koristite opisna/imena koja otkrivaju nameru Drugi programeri treba da mogu da shvate šta promenljiva sadrži samo čitajući njeno ime.

Ovo je loše

c = 5 d = 12

Ovo je dobro

brojač_gradova = 5 proteklo_vreme_u_danima = 12

3. Koristite izgovorljiva imena Uvek treba koristiti izgovorljiva imena; inače ćete imati problema sa objašnjavanjem vaših algoritama naglas.

from datetime import datetime

Ovo je loše

genyyyymmddhhmmss = datetime.strptime(’04/27/95 07:14:22′, ‘%m/%d/%y %H:%M:%S’)

Ovo je dobro

generacijski_datum_vremena = datetime.strptime(’04/27/95 07:14:22′, ‘%m/%d/%y %H:%M:%S’) 4. Izbegavajte upotrebu dvosmislenih skraćenica Ne pokušavajte da smislite svoje skraćenice. Bolje je da promenljiva ima duže ime nego zbunjujuće ime.

Ovo je loše

fna = ‘Bob’ cre_tmstp = 1621535852

Ovo je dobro

prvo_ime = ‘Bob’ vreme_kreiranja = 1621535852

5. Uvek koristite isti vokabular Izbegavajte korišćenje sinonima pri imenovanju promenljivih.

Ovo je loše

ime_klijenta = ‘Bob’ prezime_kupca = ‘Smith’

Ovo je dobro

ime_klijenta = ‘Bob’ prezime_klijenta = ‘Smith’

6. Ne koristite „čarobne brojeve“ Čarobni brojevi su čudni brojevi koji se pojavljuju u kodu, koji nemaju jasno značenje. Pogledajmo primer:

import random

Ovo je loše

def roll(): return random.randint(0, 36) # šta 36 treba da predstavlja?

Ovo je dobro

ROULETTE_POCKET_COUNT = 36

def roll(): return random.randint(0, ROULETTE_POCKET_COUNT) Umesto da koristimo čarobne brojeve, možemo ih izvući u smislenu promenljivu.

7. Koristite imena domena rešenja Ako koristite puno različitih tipova podataka u vašem algoritmu ili klasi i ne možete ih razumeti iz samog imena promenljive, ne bojte se da dodate sufiks tipa podataka imenu vaše promenljive. Na primer:

Ovo je dobro

lista_rezultata = [12, 33, 14, 24] rečnik_reči = { ‘a’: ‘jabuka’, ‘b’: ‘banana’, ‘c’: ‘višnja’, } A evo lošeg primera (jer ne možete odrediti tip podataka iz imena promenljive):

Ovo je loše

imena = [„Nick“, „Mike“, „John“] 8. Ne dodavajte suvišni kontekst Nemojte dodavati nepotrebne podatke imenima promenljivih, posebno ako radite sa klasama.

Ovo je loše

klasa Osoba: def init(self, osoba_prvo_ime, osoba_prezime, osoba_godine): self.osoba_prvo_ime = osoba_prvo_ime self.osoba_prezime = osoba_prezime self.osoba_godine = osoba_godine

Ovo je dobro

klasa Osoba: def init(self, prvo_ime, prezime, godine): self.prvo_ime = prvo_ime self.prezime = prezime self.godine = godine Već smo unutar klase Osoba, tako da nema potrebe da dodajemo prefiks osoba_ svakom klasičnom varijabilnom.

Funkcije

1. Koristite glagole za imena funkcija
2. Ne koristite različite reči za isti koncept Odaberite reč za svaki koncept i držite se nje. Korišćenje različitih reči za isti koncept izazvaće konfuziju.

Ovo je loše

def dobij_ime(): pass def dohvati_godine(): pass

Ovo je dobro

def dobij_ime(): pass def dobij_godine(): pass

3. Pišite kratke i jednostavne funkcije
4. Funkcije bi trebale samo obavljati jedan zadatak Ako vaša funkcija sadrži ključnu reč ‘i’, verovatno je možete podeliti na dve funkcije. Pogledajmo primer:

Ovo je loše

def dohvati_i_prikaz_osoblje(): podaci = # …

bashCopy codeza osobu u podacima:
    print(persona)

Ovo je dobro

def dohvati_osoblje(): vrati # …

def prikaži_osoblje(podaci): za osobu u podacima: print(osoba) Funkcije treba da rade jednu stvar i, kao čitaoci, one rade ono što očekujete da rade.

Dobar pokazatelj je da svaka data funkcija ne bi trebalo da traje duže od nekoliko minuta za shvatanje. Vratite se i pregledajte neki svoj stari kod koji ste pisali pre nekoliko meseci. Verovatno biste trebali refaktorisati svaku funkciju koja vam treba više od pet minuta da biste razumeli. Ovo je vaš kod, nakon svega. Razmislite koliko će drugom programeru trebati vremena da shvati.

5. Držite argumente na minimumu Argumente u vašoj funkciji treba držati na minimumu. Idealno, vaše funkcije bi trebale imati samo jedan do dva argumenta. Ako treba da pružite više argumenata funkciji, možete kreirati objekat konfiguracije koji ćete preneti funkciji ili je podeliti na više funkcija.

Primer:

Ovo je loše

def prikaži_blog_post(naslov, autor, vreme_kreiranja, vreme_ažuriranja, sadržaj): # …

prikaži_blog_post(„Čist kod“, „Nik Tomazic“, 1622148362, 1622148362, „…“)

Ovo je dobro

klasa BlogPost: def init(self, naslov, autor, vreme_kreiranja, vreme_ažuriranja, sadržaj): self.naslov = naslov self.autor = autor self.vreme_kreiranja = vreme_kreiranja self.vreme_ažuriranja = vreme_ažuriranja self.sadržaj = sadržaj

blog_post1 = BlogPost(„Čist kod“, „Nik Tomazic“, 1622148362, 1622148362, „…“)

def prikaži_blog_post(blog_post): # …

prikaži_blog_post(blog_post1) 6. Ne koristite zastavice u funkcijama Zastavice su promenljive (obično boolski tip) koje se prenose funkcijama, koje funkcija koristi da bi odredila svoje ponašanje. Smatraju se lošim dizajnom jer funkcije treba samo da obavljaju jedan zadatak. Najlakši način da izbegnete zastavice je podeliti vašu funkciju na manje funkcije.

tekst = „Ovo je kul blog post.“

Ovo je loše

def transformiši(tekst, veliko_slovo): ako veliko_slovo: vrati tekst.veliko_slovo() inače: vrati tekst.malo_slovo()

veliki_tekst = transformiši(tekst, True) mali_tekst = transformiši(tekst, False)

Ovo je dobro

def veliko_slovo(tekst): vrati tekst.veliko_slovo()

def malo_slovo(tekst): vrati tekst.malo_slovo()

veliki_tekst = veliko_slovo(tekst) mali_tekst = malo_slovo(tekst)

7. Izbegavajte nuspojave Funkcija proizvodi nuspojavu ako radi bilo šta osim uzimanja vrednosti unutra i vraćanja druge vrednosti ili vrednosti. Na primer, nuspojava može biti pisanje u fajl ili izmena globalne promenljive.

Komentari Bez obzira koliko se trudimo da pišemo čist kod, uvek će postojati delovi vašeg programa koji zahtevaju dodatno objašnjenje. Komentari nam omogućavaju da brzo objasnimo drugim programerima (i našim budućim ja) zašto smo napisali na način na koji jesmo. Imajte na umu da dodavanje previše komentara može učiniti vaš kod neurednijim nego što bi bio bez njih.

Koja je razlika između komentara koda i dokumentacije?

Vrsta Odgovori Aktor Dokumentacija Kada i kako Korisnici Komentari koda Zašto Programeri Čist kod Šta Programeri Za više informacija o razlikama između komentara koda i dokumentacije, pogledajte članak o Dokumentovanju Python koda i projekata.

1. Ne komentarišite loš kod, prepišite ga Komentarisanje lošeg koda — npr., # TODO: PREPISATI OVO DA BUDE BOLJE — pomaže vam samo kratkoročno. Pre ili kasnije, jedan od vaših kolega će morati raditi sa vašim kodom i završiće prepisivanjem nakon što provede više sati pokušavajući da shvati šta radi.
2. Čitljiv kod ne treba komentare Ako je vaš kod dovoljno čitljiv, ne trebate komentare. Dodavanje beskorisnih komentara će samo učiniti vaš kod manje čitljivim. Evo lošeg primera:

Ovo proverava da li korisnik sa datim ID-em ne postoji.

ako ne User.objects.filter(id=user_id).exists(): vrati Response({ ‘detalj’: ‘Korisnik sa ovim ID-em ne postoji.’, }) Kao opšte pravilo, ako morate dodati komentare, trebali bi objasniti „zašto“ ste nešto uradili umesto „šta“ se dešava.

3. Ne dodavajte komentare buke Ne dodajte komentare koji ne dodaju ništa od vrednosti kodu. Ovo je loše:

brojevi = [1, 2, 3, 4, 5]

Ova promenljiva čuva prosečno broj liste brojeva.

prosečno = sum(brojeva) / len(brojeva) print(prosečno) Ovo je takođe loše:

Kratka rečenica o mački u komentaru

4. Koristite ispravne vrste komentara Većina programskih jezika ima različite tipove komentara. Naučite njihove razlike i koristite ih u skladu s tim. Takođe bi trebali naučiti sintaksu za dokumentacione komentare. Dobar primer:

def model_to_dict(instance, fields=None, exclude=None): „““ Vraća dict koji sadrži podatke u instance pogodne za proslanje kao početni ključni argument Forme. polja je opcioni spisak imena polja. Ako je pružen, vrati samo imenovana. isključi je opcioni spisak imena polja. Ako je pružen, isključi imenovane iz vraćenog dict-a, čak i ako su navedeni u polja argumentu. „““ opcije = instance._meta podaci = {} za f u chain(opcije.konkretnim_poljima, opcije.privatnim_poljima, opcije.mnogi_do_mnogi): ako ne getattr(f, ‘uredivo’, False): nastavi ako polja nije None i f.ime nije u polja: nastavi ako isključi i f.ime u isključi: nastavi podaci[f.ime] = f.vrednost_od_objekta(instance) vrati podatke 5. Ne ostavljajte zakomentiran kod Najgora stvar koju možete uraditi je da ostavite zakomentirani kod u vašim programima. Sav debug kod ili debug poruke treba da budu uklonjeni pre nego što ih pošaljete u verzioni kontrolni sistem, inače će se vaši kolege uplašiti da ga obrišu i vaš zakomentirani kod će ostati tu zauvek.

Dekoratori, upravljači kontekstom, iteratori i generatori U ovoj sekciji ćemo pogledati neke koncepte i trikove Python-a koje možemo koristiti da napišemo bolji kod.

Dekoratori Dekoratori su izuzetno moćan alat u Python-u, koji nam omogućava da dodamo neku prilagođenu funkcionalnost funkciji. U svojoj srži, oni su samo funkcije koje se pozivaju unutar funkcija. Korišćenjem njih, iskoristimo SoC (Separation of concerns) princip i učinimo naš kod modularnijim. Naučite ih i bićete na putu do pythoničan kod-a!

Recimo da imamo server koji je zaštićen lozinkom. Možemo ili pitati za lozinku u svakoj serverskoj metodi ili stvoriti dekorator i zaštititi naše serverske metode na sledeći način:

def pitaj_za_lozinku(funkcija): def unutrašnja(): print(‘Koji je lozinka?’) lozinka = input()

bashCopy code    ako lozinka nije '1234':
        print('Pogrešna lozinka.')
    inače:
        print('Pristup dopušten.')
        funkcija()

vrati unutrašnju

@pitaj_za_lozinku def pokreni(): print(„Server je pokrenut.“)

@pitaj_za_lozinku def završi(): print(„Server je zaustavljen.“)

pokreni() # dekorator će tražiti lozinku završi() # dekorator će tražiti lozinku Naš server će sada tražiti lozinku svaki put kada se pozove pokreni() ili završi().

Upravljači kontekstom Upravljači kontekstom pojednostavljuju način na koji komuniciramo sa spoljašnjim resursima, kao što su fajlovi i baze podataka. Najčešća upotreba je sa saopštenjem with. Dobra stvar u vezi sa njima je da automatski dealociraju memoriju izvan svog bloka.

Pogledajmo primer:

with open(‘mudrost.txt’, ‘w’) kao otvoren_fajl: otvoren_fajl.piši(‘Python je kul.’)

otvoren_fajl je zatvoren.

Bez upravljača kontekstom, naš kod bi izgledao ovako:

fajl = open(‘mudrost.txt’, ‘w’) pokušaj: fajl.piši(‘Python je kul.’) napokon: fajl.zatvori() Iteratori Iterator je objekat koji sadrži prebrojivu količinu vrednosti. Iteratori omogućavaju da se objekat iterira, što znači da možete proći kroz sve vrednosti.

Recimo da imamo listu imena i želimo da je prođemo. Možemo je proći koristeći sledeći redosled imena:

imena = [„Mike“, „John“, „Steve“] iterator_imena = iter(imena)

za i u opsegu(len(imena)): print(next(iterator_imena)) Ili koristiti unapređenu petlju:

imena = [„Mike“, „John“, „Steve“]

za ime u imenima: print(ime) Unutar unapređenih petlji izbegavajte korišćenje imena promenljivih poput stavka ili vrednost jer otežava razumevanje šta promenljiva skladišti, posebno u ugnježdenim unapređenim petljama.

Generatori Generator je funkcija u Python-u koja vraća iterator objekat umesto jedne jedine vrednosti. Glavna razlika između normalnih funkcija i generatora je da generatori koriste ključnu reč yield umesto return. Svaka sledeća vrednost u iteratoru se dobija pomoću next(generator).

Recimo da želimo generisati prve n višekratnike x. Naš generator bi izgledao ovako:

def generator_višekratnika(x, n): za i u opsegu(1, n + 1): yield x * i

višekratnici_od_5 = generator_višekratnika(5, 3) print(next(višekratnici_od_5)) # 5 print(next(višekratnici_od_5)) # 10 print(next(višekratnici_od_5)) # 15 Modularnost i klase Kako biste održali vaš kod što organizovanijim, trebali biste ga podeliti u više fajlova koji su zatim podeljeni u različite direktorijume. Ako pišete kod u objektno orijentisanom jeziku, trebali biste takođe slediti osnovne OOP principe poput enkapsulacije, apstrakcije, nasleđivanja i polimorfizma.

Podela koda u više klasa će učiniti vaš kod lakšim za razumevanje i održavanje. Ne postoji fiksno pravilo o tome koliko treba da traje fajl ili klasa, ali pokušajte da ih držite malim (po mogućnosti ispod 200 linija).

Podrazumevana struktura Django projekta dobar je primer kako vaš kod treba biti strukturiran:

awesomeproject/ ├── main/ │ ├── init.py │ ├── asgi.py │ ├── settings.py │ ├── urls.py │ └── wsgi.py ├── blog/ │ ├── migrations/ │ │ └── init.py │ ├── init.py │ ├── admin.py │ ├── apps.py │ ├── models.py │ ├── tests.py │ ├── urls.py │ └── views.py └── templates Django je MTV (Model – Template – View) okvir, koji je sličan MVC okviru koji smo ranije razgovarali. Ovaj obrazac deli logiku programa u tri međusobno povezana dela.

Možete videti da je svaka aplikacija u zasebnom direktorijumu i da svaki fajl služi jednoj specifičnoj stvari. Ako je vaš projekat podeljen u više aplikacija, trebali biste osigurati da aplikacije ne zavise previše jedna od druge.

Testiranje Kvalitetan softver ne dolazi bez testova. Testiranje softvera omogućava nam da otkrijemo greške i nedostatke u softveru pre nego što se on distribuira. Testovi su od iste važnosti kao i produkcijski kod i trebali biste posvetiti značajnu količinu vremena na njima.

Za više informacija o testiranju čistog koda i pisanju čistog koda za testiranje, pogledajte sledeće članke:

Testiranje u Python-u Savremeni razvoj vođen testovima u Python-u Zaključak Pisanje čistog koda je teško. Ne postoji jedinstven recept koji možete pratiti kako biste napisali dobar, čist kod. Potrebno je vreme i iskustvo da biste ovladali tim veštinama. Pogledali smo neke standarde kodiranja i opšte smernice koje vam mogu pomoći da pišete bolji kod.

Jedan od najboljih saveta koje vam mogu dati je da ostanete dosledni i pokušate da pišete jednostavan kod koji je lako testirati. Ako otkrijete da je vaš kod težak za testiranje, verovatno je težak za korišćenje.