În timp ce învățați programarea și citirea unor resurse, ați fi dat peste acest cuvânt „abstractizare” care înseamnă pur și simplu să reduceți și să refolosiți codul cât mai mult posibil.

Funcțiile și modulele facilitează abstractizarea. Creați funcții atunci când doriți să faceți ceva în mod repetat într-un fișier.

Modulele intră în imagine atunci când doriți să reutilizați un grup de funcții în diferite fișiere sursă. Modulele sunt, de asemenea, utile în structurarea bine a programului.

  • Utilizarea bibliotecilor standard și a altor module terțe
  • Structurarea programului

Utilizarea bibliotecilor standard

Exemplu: Puteți citi despre metodele / funcțiile tuturor bibliotecilor standard din Python Docs oficial în detaliu.

import time
for i in range(100):
    time.sleep(1)   # Waits for 1 second and then executes the next command
    print(str(i) + ' seconds have passed')  # prints the number of seconds passed after the program was started
: rachetă:

Rulați Codul

# To calculate the execution time of a part of program
import time
start = time.time()
# code here
end = time.time()
print('Execution time:' , end-start)
: rachetă:

Rulați Codul

# Using math Module
import math
print(math.sqrt(100))   # prints 10
: rachetă:

Rulați Codul

Utilizarea modulelor terță parte

Modulele terțelor părți nu vin la pachet cu Python, dar trebuie să le instalăm extern folosind manageri de pachete precum pip și easy install

# To make http requests
import requests
rq = requests.get(target_url)
print(rq.status_code)

Aflați mai multe despre modulul python-requests Aici

Pentru a structura programe

Vrem să realizăm un program care are diverse funcții în ceea ce privește numerele prime. Asadar, hai sa incepem. Vom defini toate funcțiile din prime_functions.py

# prime_functions.py
from math import ceil, sqrt
def isPrime(a):
    if a == 2:
        return True
    elif a % 2 == 0:
        return False
    else:
        for i in range(3,ceil(sqrt(a)) + 1,2):
            if a % i == 0:
                return False
        return True

def print_n_primes(a):
    i = 0
    m = 2
    while True:
        if isPrime(m) ==True:
            print(m)
            i += 1
        m += 1
        if i == a:
            break

Acum vrem să folosim funcțiile pe care tocmai le-am creat prime_functions.py deci creăm un fișier nou playground.py pentru a utiliza acele funcții.

Vă rugăm să rețineți că acest program este mult prea simplu pentru a crea două fișiere separate, este doar pentru a demonstra. Dar când există programe complexe mari, realizarea de fișiere diferite este cu adevărat utilă.

# playground.py
import prime_functions
print(prime_functions.isPrime(29)) # returns True

Sortarea importurilor

Buna practică este să sortezi import module în trei grupuri – importuri standard de biblioteci, importuri legate de terțe părți și importuri locale. În cadrul fiecărui grup este sensibil să sortați alfabetic după numele modulului. Puteți găsi mai multe informații în PEP8.

Unul dintre cele mai importante lucruri pentru limbajul Python este lizibilitatea, iar modulele de sortare alfabetică sunt mai ușor de citit și căutat. De asemenea, este mai ușor să verificați dacă este importat ceva și să evitați importurile duplicate.

Din X import Y: un exemplu

Iată un exemplu de problemă:

>>> from math import ceil, sqrt
>>> # here it would be
>>> sqrt(36)
<<< 6
: rachetă:

Rulați Codul

Sau am putea să-l folosim în schimb:

>>> import math
>>> # here it would be
>>> math.sqrt(36)
<<< 6
: rachetă:

Rulați Codul

Atunci codul nostru ar arăta ca. math.sqrt(x) în loc de sqrt(x). Acest lucru se întâmplă pentru că atunci când folosim import x, un spațiu de nume x este creat în sine pentru a evita conflictele de nume. Trebuie să accesați fiecare obiect al modulului ca x.<name>.

Dar când folosim from x import y suntem de acord să adăugăm y la principalul spațiu de nume global. Deci, în timp ce folosim acest lucru, trebuie să ne asigurăm că nu avem un obiect cu același nume în programul nostru.

Nu folosiți niciodată from x import y dacă un obiect numit y deja exista

De exemplu, în os modul există o metodă open. Dar chiar avem o funcție încorporată numită open. Deci, aici ar trebui să evităm utilizarea from os import open.

Putem chiar să folosim form x import *, acest lucru ar importa toate metodele, clasele acelui modul în spațiul de nume global al programului. Aceasta este o practică proastă de programare. Vă rog să o evitați.

În general, ar trebui să evitați from x import y pur și simplu din cauza problemelor pe care le poate provoca în programele la scară largă. De exemplu, nu știți niciodată dacă un coleg programator ar putea dori să creeze o nouă funcție care se întâmplă să fie numele uneia dintre funcțiile existente. De asemenea, nu știți dacă Python va schimba biblioteca din care importați funcțiile. Deși aceste probleme nu vor exista atât de des pentru proiectele solo, așa cum am menționat anterior, este o practică proastă de programare și ar trebui evitată.