În acest tutorial, vom afla despre tipurile constante și despre cum acestea ajută la îmbunătățirea lizibilității codului. Dacă nu sunteți familiarizat, constantele sunt nume care reprezintă valori care nu se modifică în timpul execuției programului. Ele sunt cel mai comun concept fundamental în programare. Cu toate acestea, Python nu are o sintaxă dedicată pentru definirea constantelor. În general, constantele Python sunt variabile care nu se modifică niciodată. Vom avea o discuție detaliată despre constanta Python în secțiunea următoare.

Ce sunt constantele?

În general, în matematică se folosește un termen constant, o valoare sau o cantitate care nu se schimbă niciodată. În programare, o constantă se referă la numele asociat unei valori care nu se modifică niciodată în timpul execuției programării. Constanta de programare este diferită de alte constante și constă din două lucruri - un nume și o valoare asociată. Numele va descrie despre ce este constanta, iar valoarea este expresia concretă a constantei în sine.

Odată ce definim constanta, putem accesa doar valoarea acesteia, dar nu o putem modifica în timp. Cu toate acestea, putem modifica valoarea variabilei. Un exemplu din viața reală este: viteza luminii, numărul de minute într-o oră și numele folderului rădăcină al unui proiect.

De ce să folosiți constant?

În limbajele de programare, constantele ne permit să ne protejăm împotriva modificării accidentale a valorii lor, ceea ce poate cauza erori greu de depanat. De asemenea, este util să faceți codul mai lizibil și mai ușor de întreținut. Să vedem câteva avantaje ale constantei.

Lizibilitate îmbunătățită -Ajută la îmbunătățirea lizibilității codului. De exemplu, este mai ușor să citiți și să înțelegeți o constantă numită MAX_SPEED decât valoarea substanțială a vitezei în sine.Comunicarea clară a intenției -Majoritatea dezvoltatorilor consideră că 3.14 este constanta pi. Cu toate acestea, numele Pi, pi sau PI va comunica mai clar intenția. Această practică va permite unui alt dezvoltator să înțeleagă codul nostru.O mai bună întreținere -Constantele ne permit să folosim aceeași valoare în întregul cod. Să presupunem că vrem să actualizăm valoarea constantei; nu trebuie să schimbăm fiecare instanță.Risc scăzut de erori -O constantă care reprezintă o valoare dată în cadrul unui program este mai puțin predispusă la erori. Dacă vrem să schimbăm precizia în calcule, înlocuirea valorii poate fi riscantă. În loc să-l înlocuim, putem crea diferite constante pentru diferite niveluri de precizie și putem schimba codul acolo unde avem nevoie.Stocare de date sigură pentru fire -Constantele A sunt obiecte sigure pentru fire, ceea ce înseamnă că mai multe fire pot folosi simultan o constantă fără a risca pierderea datelor.

Constante definite de utilizator

Trebuie să folosim convenția de denumire în Python pentru a defini constanta în Python. Ar trebui să scriem numele cu majuscule, cu caractere de subliniere care separă cuvintele.

Următoarele sunt exemplele constantelor Python definite de utilizator -

 PI = 3.14 MAX_SPEED = 300 DEFAULT_COLOR = '33[1;34m' WIDTH = 20 API_TOKEN = '567496396372' BASE_URL = 'https://api.example.com' DEFAULT_TIMEOUT = 5 BUILTINS_METHODS = ('sum', 'max', 'min', 'abs') INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', ... ] 

Am folosit același mod în care creăm variabile în Python. Deci putem presupune că constantele Python sunt doar variabile și singura distincție este că constanta folosește doar litere mari.

Utilizarea literelor mari face ca constanta să iasă în evidență de variabilele noastre și este o practică utilă sau preferată.

Mai sus am discutat despre utilizatorii definiți de utilizator; Python oferă, de asemenea, câteva nume interne care pot lua în considerare și ar trebui să le trateze ca constante.

Constante importante în Python

În această secțiune, vom afla despre unele constante interne care sunt folosite pentru a face codul Python mai ușor de citit. Să înțelegem câteva constante importante.

Constante încorporate

În documentația oficială, Adevărat și Fals sunt listate ca prima constantă. Acestea sunt valori booleene Python și sunt instanța int. A Adevărat are valoarea 1 și Fals are valoarea 0.

unghiuri adiacente

Exemplu -

 >>> True True >>> False False >>> isinstance(True, int) True >>> isinstance(False, int) True >>> int(True) 1 >>> int(False) 0 >>> True = 42 ... SyntaxError: cannot assign to True >>> True is True True >>> False is False True 

Amintiți-vă că numele Adevărat și Fals sunt constante stricte. Cu alte cuvinte, nu le putem reatribui, iar dacă încercăm să le reatribuim, vom obține o eroare de sintaxă. Aceste două valori sunt obiecte singleton în Python, ceea ce înseamnă că există o singură instanță.

Nume interne Dunder

Python are, de asemenea, multe interne tunet nume pe care le putem considera constante. Există mai multe dintre aceste nume unice, vom afla despre __name__ și __file__ în această secțiune.

Atributul __name__ este legat de modul în care se rulează o anumită bucată de cod. La importul unui modul, Python intern setează __name__ la un șir care conține numele modulului.

fişier_nou.py

 print(f'The type of __name__ is: {type(__name__)}') print(f'The value of __name__ is: {__name__}') 

În linia de comandă și tastați următoarea comandă -

 python -c 'import new_file' 

-c este folosit pentru a executa o mică bucată de cod Python la linia de comandă. În exemplul de mai sus, am importat fişier_nou modul, care afișează unele mesaje pe ecran.

Ieșire -

 The type of __name__ is: The value of __name__ is: timezone 

După cum putem vedea că __name__ stochează șirul __main__, indică faptul că putem rula fișierele executabile direct ca program Python.

sortați o matrice java

Pe de altă parte, atributul __file__ are fișierul pe care Python îl importă sau îl execută în prezent. Dacă folosim atributul __file__ în interiorul fișierului, vom obține calea către modul însuși.

Să vedem următorul exemplu -

Exemplu -

 print(f'The type of __file__ is: {type(__file__)}') print(f'The value of __file__ is: {__file__}') 

Ieșire:

 The type of __file__ is: The value of __file__ is: D:Python Project
ew_file.py 

De asemenea, putem rula direct și vom obține același rezultat.

Exemplu -

 print(f'The type of __file__ is: {type(__file__)}') print(f'The value of __file__ is: {__file__}') 

Ieșire:

 python new_file.py The type of __file__ is: The value of __file__ is: timezone.py 

șiruri utile și constante matematice

Există multe constante valoroase în biblioteca standard. Unele sunt strict conectate la anumite module, funcții și clase; multe sunt generice și le putem folosi în mai multe scenarii. În exemplul de mai jos, vom folosi modulele matematice și, respectiv, legate de șiruri, math și șir.

Să înțelegem următorul exemplu -

Exemplu -

 >>> import math >>> math.pi 3.141592653589793 >>> math.tau 6.283185307179586 >>> math.nan nan >>> math.inf inf >>> math.sin(30) -0.9880316240928618 >>> math.cos(60) -0.9524129804151563 >>> math.pi 3.141592653589793 

Aceste constante vor juca un rol vital atunci când scriem cod legat de matematică sau efectuăm unele calcule specifice.

Să înțelegem următorul exemplu -

ce este o stivă în java

Exemplu -

 import math class Sphere: def __init__(self, radius): self.radius = radius def area(self): return math.pi * self.radius**2 def perimeter(self): return 2 * math.pi * self.radius def projected_volume(self): return 4/3 * math.pi * self.radius**3 def __repr__(self): return f'{self.__class__.__name__}(radius={self.radius})' 

În codul de mai sus, am folosit matematică.pi în loc de obicei PI constante. Constanta legată de matematică oferă cu atât mai multe contexte programului. Avantajul utilizării constantei math.pi este că, dacă folosim o versiune mai veche de Python, vom obține o versiune de Pi pe 32 de biți. Dacă folosim programul de mai sus în versiunea modernă de Python, vom obține o versiune de pi pe 64 de biți. Așadar, programul nostru se va autoadapta mediului său concret de execuție.

Modulul șir oferă, de asemenea, câteva constante de șir încorporate utile. Mai jos este tabelul cu numele și valoarea fiecărei constante.

Putem folosi aceste constante legate de șiruri în expresii regulate, procesarea limbajului natural, cu multe procesări de șiruri și multe altele.

Constante de adnotare de tip

Începând cu Python 3.8, modulul de tastare include o clasă Final care ne permite să adnotăm constante. Dacă folosim clasa Final pentru a defini constantele din program, vom obține eroarea de tip static pe care verificatorul mypy o verifică și va arăta că nu putem reatribui numelui Final. Să înțelegem următorul exemplu.

Exemplu -

 from typing import Final MAX_Marks: Final[int] = 300 MAX_Students: Final[int] = 500 MAX_Marks = 450 # Cannot assign to final name 'MAX_SPEED' mypy(error) 

Am specificat variabila constantă cu Clasa finală care a indicat eroarea de tip pentru a raporta o eroare dacă un nume declarat este reatribuit. Cu toate acestea, primește un raport al erorii unui verificator de tip; Python modifică valoarea MAX_SPEED. Deci, Final nu împiedică reatribuirea accidentală constantă în timpul execuției.

Constante de șir

După cum sa discutat în secțiunea anterioară, Python nu acceptă constante stricte; are doar variabile care nu se schimbă niciodată. Prin urmare, comunitatea Python urmează convenția de denumire a utilizării literei mari pentru a identifica variabilele constante.

Poate fi o problemă dacă lucrăm la un proiect mare Python cu mulți programatori la diferite niveluri. Deci ar fi o bună practică să avem un mecanism care să ne permită să folosim constante stricte. După cum știm, Python este un limbaj dinamic și există mai multe moduri de a face constantele neschimbabile. În această secțiune, vom afla despre unele dintre aceste moduri.

Atributele .__slots__

Clasele Python oferă posibilitatea de a utiliza atributele __slots__. Slotul are mecanismul special pentru a reduce dimensiunea obiectelor. Este un concept de optimizare a memoriei pe obiecte. Dacă folosim atributul __slots__ în clasă, nu vom putea adăuga noua instanță, deoarece nu folosește atributele __dict__. În plus, neavând un .__dict__ atributul implică o optimizare în ceea ce privește consumul de memorie. Să înțelegem următorul exemplu.

Exemplu - Fără a utiliza atributele __slots__

 class NewClass(object): def __init__(self, *args, **kwargs): self.a = 1 self.b = 2 if __name__ == '__main__': instance = NewClass() print(instance.__dict__) 

Ieșire -

 {'a': 1, 'b': 2} 

Fiecare obiect din Python conține un dicționar dinamic care permite adăugarea de atribute. Dicționarele consumă multă memorie, iar utilizarea __slots__ reduce risipa de spațiu și memorie. Să vedem un alt exemplu.

Exemplu -

 class ConstantsName: __slots__ = () PI = 3.141592653589793 EULER_NUMBER = 2.718281828459045 constant = ConstantsName() print(constant.PI) print(constant.EULER_NUMBER) constant.PI = 3.14 print(constant.PI) 

Ieșire -

 3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 10, in AttributeError: 'ConstantsName' object attribute 'PI' is read-only 

În codul de mai sus, am inițializat atributele clasei cu atributele slots. Variabila are o valoare constantă, dacă încercăm să reatribuim variabila, vom obține o eroare.

npm șterge memoria cache

Decoratorul @property

Putem folosi, de asemenea @proprietate decorator pentru a crea o clasă care funcționează ca spațiu de nume pentru constante. Trebuie doar să definim proprietatea constantelor fără a le furniza o metodă setter. Să înțelegem următorul exemplu.

Exemplu -

 class ConstantsName: @property def PI(self): return 3.141592653589793 @property def EULER_NUMBER(self): return 2.718281828459045 constant = ConstantsName() print(constant.PI) print(constant.EULER_NUMBER) constant.PI = 3.14 print(constant.PI) 

Ieșire -

 3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 13, in AttributeError: can't set attribute 

Sunt doar proprietăți numai pentru citire, dacă încercăm să le reatribuim, vom obține un AttributeError.

Funcția de fabrică namedtuple().

Modulul de colectare al lui Python vine cu funcția din fabrică numită namedtuple(). Folosind namedtuple() funcția, putem folosi câmpurile numite și notația cu puncte pentru a accesa articolele lor. Știm că tuplurile sunt imuabile, ceea ce înseamnă că nu putem modifica un obiect tuplu numit existent în loc.

Să înțelegem următorul exemplu.

Exemplu -

 from collections import namedtuple ConstantsName = namedtuple( 'ConstantsName', ['PI', 'EULER_NUMBER'] ) constant = ConstantsName(3.141592653589793, 2.718281828459045) print(constant.PI) print(constant.EULER_NUMBER) constant.PI = 3.14 print(constant.PI) 

Ieșire -

 3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 17, in AttributeError: can't set attribute 

Decoratorul @dataclass

După cum sugerează și numele, clasa de date conține date, acestea pot consta din metode, dar nu este scopul lor principal. Trebuie să folosim decoratorul @dataclass pentru a crea clasele de date. De asemenea, putem crea constante stricte. Decoratorul @dataclass acceptă un argument înghețat care ne permite să ne marchem clasa de date ca imuabilă. Avantajele utilizării @dataclass decorator, nu putem modifica atributul instanței acestuia.

Să înțelegem următorul exemplu.

b+ arbore

Exemplu -

 from dataclasses import dataclass @dataclass(frozen=True) class ConstantsName: PI = 3.141592653589793 EULER_NUMBER = 2.718281828459045 constant = ConstantsName() print(constant.PI) print(constant.EULER_NUMBER) constant.PI = 3.14 print(constant.PI) 

Ieșire -

 3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 19, in File '', line 4, in __setattr__ dataclasses.FrozenInstanceError: cannot assign to field 'PI' 

Explicație -

În codul de mai sus, am importat decoratorul @dataclass. Am folosit acest decorator la ConstantsName pentru a-l face o clasă de date. Am setat argumentul înghețat la True pentru a face clasa de date imuabilă. Am creat instanța clasei de date și putem accesa toate constantele, dar nu le putem modifica.

Metoda specială .__setattr__().

Python ne permite să folosim o metodă specială numită .__setattr__(). Folosind această metodă, putem personaliza procesul de atribuire a atributelor, deoarece Python apelează automat metoda la fiecare atribuire a atributelor. Să înțelegem următorul exemplu -

Exemplu -

 class ConstantsName: PI = 3.141592653589793 EULER_NUMBER = 2.718281828459045 def __setattr__(self, name, value): raise AttributeError(f'can't reassign constant '{name}'') constant = ConstantsName() print(constant.PI) print(constant.EULER_NUMBER) constant.PI = 3.14 print(constant.PI) 

Ieșire -

 3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 22, in File '', line 17, in __setattr__ AttributeError: can't reassign constant 'PI' 

Metoda __setattr__() nu permite efectuarea nicio operațiune de atribuire asupra atributelor clasei. Dacă încercăm să reatribuim, se ridică doar un AttributeError.

Concluzie

Constantele sunt cele mai utilizate în concept în programare, în special în termeni matematici. În acest tutorial, am învățat despre conceptele importante ale constantelor și aromele acesteia. Comunitatea Python folosește literele mari ca convenție de nume pentru a identifica constantele. Cu toate acestea, am discutat câteva modalități avansate de utilizare a constantelor în Python. Am discutat despre cum să îmbunătățim lizibilitatea, reutilizarea și mentenabilitatea codului cu constante. Am menționat cum să aplicăm diverse tehnici pentru a face constantele noastre Python strict constante.