I den här handledningen kommer vi att lära oss om konstanttyperna och hur de hjälper till att förbättra kodläsbarheten. Om du inte är bekant är konstanterna de namn som representerar värden som inte ändras under programmets körning. De är det vanligaste grundläggande konceptet inom programmering. Python har dock ingen dedikerad syntax för att definiera konstanter. I allmänhet är Python-konstanter variabla som aldrig ändras. Vi kommer att ha en detaljerad diskussion om Python-konstanten i det kommande avsnittet.
Vad är konstanter?
I allmänhet används en konstant term i matematik, ett värde eller kvantitet som aldrig ändras. I programmering hänvisar en konstant till namnet som är associerat med ett värde som aldrig ändras under programmeringsexekveringen. Programmeringskonstanten skiljer sig från andra konstanter, och den består av två saker - ett namn och ett tillhörande värde. Namnet kommer att beskriva vad konstanten handlar om, och värdet är det konkreta uttrycket för själva konstanten.
När vi väl har definierat konstanten kan vi bara komma åt dess värde men kan inte ändra det över tid. Däremot kan vi ändra värdet på variabeln. Ett exempel från verkligheten är - Ljusets hastighet, antalet minuter i en timme och namnet på ett projekts rotmapp.
Varför använda konstant?
I programmeringsspråk tillåter konstanter oss att skydda oss från att oavsiktligt ändra deras värde, vilket kan orsaka svårfelsökta fel. Det är också bra att göra koden mer läsbar och underhållbar. Låt oss se några fördelar med konstant.
Användardefinierade konstanter
Vi måste använda namnkonventionen i Python för att definiera konstanten i Python. Vi ska skriva namnet med versaler med understreck som skiljer orden åt.
Följande är exemplet på användardefinierade Python-konstanter -
lägga till sträng i java
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', ... ]
Vi har använt samma sätt som vi skapar variabler i Python. Så vi kan anta att Python-konstanter bara är variabler, och den enda skillnaden är att konstanten bara använder stora bokstäver.
Att använda stora bokstäver gör att konstanten sticker ut från våra variabler och är en användbar eller föredragen metod.
Ovan diskuterade vi de användardefinierade användarna; Python tillhandahåller också flera interna namn som kan övervägas och bör behandlas som konstanter.
Viktiga konstanter i Python
I det här avsnittet kommer vi att lära oss om några interna konstanter som används för att göra Python-koden mer läsbar. Låt oss förstå några viktiga konstanter.
Inbyggda konstanter
I den officiella dokumentationen Sann och Falsk är listade som den första konstanten. Dessa är Python Boolean-värden och är instansen av int. A Sann har värdet 1, och Falsk har ett värde 0.
Exempel -
>>> 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
Kom ihåg att Sanna och Falska namn är strikta konstanter. Med andra ord kan vi inte tilldela dem om, och om vi försöker att tilldela dem kommer vi att få ett syntaxfel. Dessa två värden är singleton-objekt i Python, vilket betyder att endast en instans existerar.
Interna Dunder-namn
Python har också många interna dunder namn som vi kan betrakta som konstanter. Det finns flera av dessa unika namn, vi kommer att lära oss om __namn__ och __fil__ i det här avsnittet.
Attributet __name__ är relaterat till hur man kör en given kod. När du importerar en modul ställer Python intern in __name__ till en sträng som innehåller modulens namn.
ny_fil.py
print(f'The type of __name__ is: {type(__name__)}') print(f'The value of __name__ is: {__name__}') På kommandoraden och skriv följande kommando -
python -c 'import new_file'
-c används för att exekvera en liten kod av Python på kommandoraden. I exemplet ovan importerade vi ny fil modul, som visar några meddelanden på skärmen.
Utgång -
The type of __name__ is: The value of __name__ is: timezone
Eftersom vi kan se att __name__ lagrar __main__-strängen, indikerar det att vi kan köra de körbara filerna direkt som Python-program.
Å andra sidan har attributet __file__ filen som Python för närvarande importerar eller kör. Om vi använder attributet __file__ inuti filen får vi sökvägen till själva modulen.
Låt oss se följande exempel -
Exempel -
print(f'The type of __file__ is: {type(__file__)}') print(f'The value of __file__ is: {__file__}') Produktion:
The type of __file__ is: The value of __file__ is: D:Python Project ew_file.py
Vi kan också köra direkt och kommer att få samma resultat.
Exempel -
print(f'The type of __file__ is: {type(__file__)}') print(f'The value of __file__ is: {__file__}') Produktion:
python new_file.py The type of __file__ is: The value of __file__ is: timezone.py
Användbara sträng- och matematikkonstanter
Det finns många värdefulla konstanter i standardbiblioteket. Vissa är strikt kopplade till specifika moduler, funktioner och klasser; många är generiska och vi kan använda dem i flera scenarier. I exemplet nedan kommer vi att använda de matematiska och strängrelaterade modulerna matematik respektive sträng.
Låt oss förstå följande exempel -
Exempel -
>>> 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
Dessa konstanter kommer att spela en viktig roll när vi skriver matematikrelaterad kod eller utför vissa specifika beräkningar.
Låt oss förstå följande exempel -
Exempel -
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})' I ovanstående kod har vi använt math.pi istället för anpassad PI konstanter. Den matematikrelaterade konstanten ger programmet fler sammanhang. Fördelen med att använda math.pi-konstanten är att om vi använder en äldre version av Python så får vi en 32-bitarsversion av Pi. Om vi använder ovanstående program i modern version av Python får vi en 64-bitars version av pi. Så vårt program kommer att anpassa sig till sin konkreta utförandemiljö.
karta i maskinskriven
Strängmodulen tillhandahåller också några användbara inbyggda strängkonstanter. Nedan finns tabellen med namn och värde för varje konstant.
| namn | Värde |
|---|---|
| ascii_små bokstäver | Abcdefghijklmnopqrstuvwxyz |
| ascii_versaler | ABCDEFGHIJKLMNOPQRSTUVWXYZ |
| ascii_bokstäver | ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz |
| siffror | 0123456789 |
| hexsiffror | 0123456789abcdefABCDEF |
| oktsiffror | 01234567 |
Vi kan använda dessa strängrelaterade konstanter i reguljära uttryck, bearbetning av naturligt språk, med mycket strängbearbetning och mer.
Konstanter för typkommentarer
Sedan Python 3.8 innehåller typmodulen en Final-klass som låter oss skriva annotera konstanter. Om vi använder klassen Final för att definiera konstanterna i programmet får vi det statiska typfelet som mypy checker kontrollerar och det kommer att visa att vi inte kan tilldela det slutliga namnet. Låt oss förstå följande exempel.
Exempel -
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)
Vi specificerade konstantvariabeln med den slutliga klassen som indikerade typfelet för att rapportera ett fel om ett deklarerat namn omtilldelas. Den får dock en rapport om ett typkontrollerfel; Python ändrar värdet på MAX_SPEED. Så, Final förhindrar inte konstant oavsiktlig omtilldelning under körning.
Strängkonstanter
Som diskuterats i det tidigare avsnittet stöder Python inte strikta konstanter; den har bara variabler som aldrig förändras. Därför följer Python-gemenskapen namnkonventionen att använda versaler för att identifiera konstantvariablerna.
Det kan vara ett problem om vi arbetar med ett stort Python-projekt med många programmerare på olika nivåer. Så det skulle vara bra att ha en mekanism som tillåter oss att använda strikta konstanter. Som vi vet är Python ett dynamiskt språk, och det finns flera sätt att göra konstanter oföränderliga. I det här avsnittet kommer vi att lära oss om några av dessa sätt.
Attributen .__slots__
Python-klasser ger möjlighet att använda attributen __slots__. Slitsen har en speciell mekanism för att minska storleken på föremålen. Det är ett koncept för minnesoptimering på objekt. Om vi använder attributet __slots__ i klassen kommer vi inte att kunna lägga till den nya instansen, eftersom den inte använder __dict__-attribut. Dessutom att inte ha en .__dict__ attribut innebär en optimering i termer av minnesförbrukning. Låt oss förstå följande exempel.
Exempel - Utan att använda __slots__-attribut
class NewClass(object): def __init__(self, *args, **kwargs): self.a = 1 self.b = 2 if __name__ == '__main__': instance = NewClass() print(instance.__dict__)
Utgång -
{'a': 1, 'b': 2} Varje objekt i Python innehåller en dynamisk ordbok som gör det möjligt att lägga till attribut. Ordböcker förbrukar mycket minne och att använda __slots__ minskar slöseri med utrymme och minne. Låt oss se ett annat exempel.
Exempel -
databasdesign i dbms
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)
Utgång -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 10, in AttributeError: 'ConstantsName' object attribute 'PI' is read-only
I ovanstående kod initierade vi klassattributen med slotsattributen. Variabeln har ett konstant värde, om vi försöker tilldela om variabeln får vi ett fel.
@fastighetsdekoratören
Vi kan också använda @fast egendom dekoratör för att skapa en klass som fungerar som ett namnområde för konstanter. Vi behöver bara definiera egenskapen konstanter utan att förse dem med en sättermetod. Låt oss förstå följande exempel.
Exempel -
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)
Utgång -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 13, in AttributeError: can't set attribute
De är bara skrivskyddade egenskaper, om vi försöker tilldela om får vi en AttributeError.
Fabriksfunktionen namedtuple()
Pythons samlingsmodul kommer med fabriksfunktionen som heter namedtuple(). Använda namedtuple() funktion, kan vi använda de namngivna fälten och punktnotationen för att komma åt deras objekt. Vi vet att tupler är oföränderliga, vilket betyder att vi inte kan modifiera ett befintligt namngivet tupelobjekt på plats.
Låt oss förstå följande exempel.
Exempel -
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)
Utgång -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 17, in AttributeError: can't set attribute
@dataclass-dekoratören
Som namnet antyder innehåller dataklassen data, de kan bestå av metoder, men det är inte deras primära mål. Vi måste använda @dataclass decorator för att skapa dataklasserna. Vi kan också skapa de strikta konstanterna. @dataclass-dekoratören tar ett fruset argument som låter oss markera vår dataklass som oföränderlig. Fördelarna med att använda @dataclass decorator, vi kan inte ändra dess instansattribut.
Låt oss förstå följande exempel.
Exempel -
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)
Utgång -
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'
Förklaring -
I ovanstående kod har vi importerat @dataclass decorator. Vi använde denna dekorator till ConstantsName för att göra det till en dataklass. Vi ställer in det frusna argumentet till True för att göra dataklassen oföränderlig. Vi skapade instansen av dataklassen, och vi kan komma åt alla konstanter men kan inte ändra dem.
.__setattr__() specialmetoden
Python tillåter oss att använda en speciell metod som heter .__setattr__(). Med den här metoden kan vi anpassa attributtilldelningsprocessen eftersom Python automatiskt anropar metoden vid varje attributtilldelning. Låt oss förstå följande exempel -
Exempel -
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) Utgång -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 22, in File '', line 17, in __setattr__ AttributeError: can't reassign constant 'PI'
Metoden __setattr__() tillåter inte att utföra någon tilldelningsoperation på klassens attribut. Om vi försöker omfördela, höjer det bara en AttributeError.
Slutsats
Konstanter används mest i koncept inom programmering, särskilt i matematisk term. I den här handledningen har vi lärt oss om de viktiga begreppen konstanter och dess smaker. Python-gemenskapen använder versaler som en namnkonvention för att identifiera konstanterna. Vi har dock diskuterat några förvägssätt att använda konstanterna i Python. Vi har diskuterat hur man kan förbättra kodens läsbarhet, återanvändbarhet och underhållbarhet med konstanter. Vi nämnde hur man tillämpar olika tekniker för att göra våra Python-konstanter strikt konstanta.