In deze zelfstudie leren we over de constante typen en hoe deze de leesbaarheid van de code helpen verbeteren. Als u niet bekend bent: de constanten zijn de namen die waarden vertegenwoordigen die niet veranderen tijdens de uitvoering van het programma. Ze zijn het meest voorkomende fundamentele concept bij programmeren. Python heeft echter geen speciale syntaxis voor het definiëren van constanten. Over het algemeen zijn Python-constanten variabel en veranderen ze nooit. We zullen in de komende sectie een gedetailleerde discussie over de Python-constante hebben.

Wat zijn constanten?

Over het algemeen wordt in de wiskunde een constante term gebruikt, een waarde of hoeveelheid die nooit verandert. Bij het programmeren verwijst een constante naar de naam die is gekoppeld aan een waarde die nooit verandert tijdens de uitvoering van het programmeren. Programmeerconstante verschilt van andere constanten en bestaat uit twee dingen: een naam en een bijbehorende waarde. De naam beschrijft waar de constante over gaat, en de waarde is de concrete uitdrukking van de constante zelf.

Zodra we de constante hebben gedefinieerd, hebben we alleen toegang tot de waarde ervan, maar kunnen we deze in de loop van de tijd niet veranderen. We kunnen de waarde van de variabele echter wijzigen. Een voorbeeld uit de praktijk is: de snelheid van het licht, het aantal minuten in een uur en de naam van de hoofdmap van een project.

Waarom Constant gebruiken?

In programmeertalen stellen constanten ons in staat te beschermen tegen het per ongeluk wijzigen van hun waarde, wat moeilijk te debuggen fouten kan veroorzaken. Het is ook nuttig om code leesbaarder en onderhoudbaarder te maken. Laten we enkele voordelen van constant bekijken.

Verbeterde leesbaarheid -Het helpt de leesbaarheid van de code te verbeteren. Het is bijvoorbeeld gemakkelijker om een ​​constante met de naam MAX_SPEED te lezen en te begrijpen dan de substantiële snelheidswaarde zelf.Duidelijke communicatie van intentie -De meeste ontwikkelaars beschouwen de 3.14 als de pi-constante. De Pi-, pi- of PI-naam zal de intentie echter duidelijker communiceren. Door deze praktijk kan een andere ontwikkelaar onze code begrijpen.Betere onderhoudbaarheid -Met constanten kunnen we dezelfde waarde in uw hele code gebruiken. Stel dat we de waarde van de constante willen bijwerken; we hoeven niet elke instantie te wijzigen.Laag risico op fouten -Een constante die een bepaalde waarde in een programma vertegenwoordigt, is minder foutgevoelig. Als we de nauwkeurigheid in de berekeningen willen veranderen, kan het vervangen van de waarde riskant zijn. In plaats van deze te vervangen, kunnen we verschillende constanten maken voor verschillende precisieniveaus en de code wijzigen waar dat nodig is.Thread-veilige gegevensopslag -Een constanten zijn thread-safe objecten, wat betekent dat meerdere threads tegelijkertijd een constante kunnen gebruiken zonder het risico te lopen gegevens te verliezen.

Door de gebruiker gedefinieerde constanten

We moeten de naamgevingsconventie in Python gebruiken om de constante in Python te definiëren. We moeten de naam in hoofdletters schrijven met onderstrepingstekens die de woorden scheiden.

Hieronder volgt een voorbeeld van de door de gebruiker gedefinieerde Python-constanten:

 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', ... ] 

We hebben dezelfde manier gebruikt waarop we variabelen maken in Python. We kunnen dus aannemen dat Python-constanten slechts variabelen zijn, en het enige verschil is dat de constante alleen hoofdletters gebruikt.

Het gebruik van hoofdletters zorgt ervoor dat de constante zich onderscheidt van onze variabelen en is een nuttige of geprefereerde praktijk.

tekenreeks omzetten in int

Hierboven hebben we de door de gebruiker gedefinieerde gebruikers besproken; Python biedt ook verschillende interne namen die als constanten kunnen worden beschouwd en moeten worden behandeld.

Belangrijke constanten in Python

In deze sectie zullen we enkele interne constanten leren kennen die worden gebruikt om Python-code leesbaarder te maken. Laten we enkele belangrijke constanten begrijpen.

Ingebouwde constanten

In de officiële documentatie staat de WAAR En Vals worden vermeld als de eerste constante. Dit zijn Python Booleaanse waarden en zijn de instantie van de int. A WAAR heeft een waarde van 1, en Vals heeft een waarde 0.

Voorbeeld -

 >>> 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 

Onthoud dat ware en valse namen strikte constanten zijn. Met andere woorden: we kunnen ze niet opnieuw toewijzen, en als we ze opnieuw proberen toe te wijzen, krijgen we een syntaxisfout. Deze twee waarden zijn singleton-objecten in Python, wat betekent dat er slechts één instantie bestaat.

Interne Dunder-namen

Python heeft ook veel interne donder namen die we als constanten kunnen beschouwen. Er zijn verschillende van deze unieke namen; we zullen in deze sectie meer leren over __naam__ en __bestand__.

Het attribuut __name__ heeft betrekking op de manier waarop een bepaald stuk code moet worden uitgevoerd. Bij het importeren van een module stelt Python intern de __name__ in op een string die de naam van de module bevat.

nieuw_bestand.py

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

Typ op de opdrachtregel de volgende opdracht:

 python -c 'import new_file' 

De -c wordt gebruikt om een ​​klein stukje Python-code op de opdrachtregel uit te voeren. In het bovenstaande voorbeeld hebben we de nieuw bestand module, die enkele berichten op het scherm weergeeft.

Uitvoer -

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

Zoals we kunnen zien, slaat de __name__ de string __main__ op, wat aangeeft dat we de uitvoerbare bestanden rechtstreeks als Python-programma kunnen uitvoeren.

Aan de andere kant bevat het attribuut __file__ het bestand dat Python momenteel importeert of uitvoert. Als we het attribuut __file__ in het bestand gebruiken, krijgen we het pad naar de module zelf.

Laten we het volgende voorbeeld bekijken -

Voorbeeld -

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

Uitgang:

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

We kunnen ook direct rennen en krijgen hetzelfde resultaat.

Voorbeeld -

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

Uitgang:

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

Handige tekenreeks- en wiskundige constanten

Er zijn veel waardevolle constanten in de standaardbibliotheek. Sommige zijn strikt verbonden met specifieke modules, functies en klassen; Velen zijn generiek en we kunnen ze in verschillende scenario's gebruiken. In het onderstaande voorbeeld gebruiken we respectievelijk de wiskunde- en stringgerelateerde modules math en string.

Laten we het volgende voorbeeld begrijpen -

Voorbeeld -

 >>> 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 

Deze constanten zullen een cruciale rol spelen wanneer we wiskundegerelateerde code schrijven of specifieke berekeningen uitvoeren.

Laten we het volgende voorbeeld begrijpen -

Voorbeeld -

 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})' 

In de bovenstaande code hebben we de wiskunde.pi in plaats van gewoonte PI constanten. De wiskundegerelateerde constante biedt des te meer contexten aan het programma. Het voordeel van het gebruik van de constante math.pi is dat als we een oudere versie van Python gebruiken, we een 32-bits versie van Pi krijgen. Als we het bovenstaande programma in de moderne versie van Python gebruiken, krijgen we een 64-bits versie van pi. Ons programma zal zich dus automatisch aanpassen aan de concrete uitvoeringsomgeving.

De stringmodule biedt ook enkele handige ingebouwde stringconstanten. Hieronder vindt u de tabel met de naam en waarde van elke constante.

We kunnen deze tekenreeksgerelateerde constanten gebruiken in reguliere expressies, bij het verwerken van natuurlijke taal, met veel tekenreeksverwerking, en meer.

Madhuri zei: kom op

Type-annoterende constanten

Sinds Python 3.8 bevat de typemodule een Final-klasse waarmee we constanten kunnen annoteren. Als we de klasse Final gebruiken om de constanten in het programma te definiëren, krijgen we de statische typefout die de mypy-checker controleert en deze zal aantonen dat we de definitieve naam niet opnieuw kunnen toewijzen. Laten we het volgende voorbeeld begrijpen.

Voorbeeld -

 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) 

We hebben de constante variabele gespecificeerd met de Final Class die de typefout aangeeft om een ​​fout te rapporteren als een opgegeven naam opnieuw wordt toegewezen. Het krijgt echter een rapport van een typecontrolefout; Python verandert de waarde van MAX_SPEED. Final voorkomt dus niet dat er voortdurend per ongeluk opnieuw wordt toegewezen tijdens runtime.

Tekenreeksconstanten

Zoals besproken in de eerdere sectie ondersteunt Python geen strikte constanten; het heeft alleen variabelen die nooit veranderen. Daarom volgt de Python-gemeenschap de naamgevingsconventie waarbij de hoofdletter wordt gebruikt om de constante variabelen te identificeren.

Het kan een probleem zijn als we aan een groot Python-project werken met veel programmeurs op verschillende niveaus. Het zou dus een goede gewoonte zijn om een ​​mechanisme te hebben waarmee we strikte constanten kunnen gebruiken. Zoals we weten is Python een dynamische taal en er zijn verschillende manieren om constanten onveranderlijk te maken. In dit gedeelte zullen we enkele van deze manieren leren kennen.

De .__slots__-attributen

Python-klassen bieden de mogelijkheid om de __slots__-attributen te gebruiken. De sleuf heeft het speciale mechanisme om de grootte van de objecten te verkleinen. Het is een concept van geheugenoptimalisatie op objecten. Als we het __slots__ attribuut in de klasse gebruiken, kunnen we de nieuwe instantie niet toevoegen, omdat deze geen __dict__ attributen gebruikt. Bovendien, het niet hebben van een .__dict__ attribuut impliceert een optimalisatie in termen van geheugengebruik. Laten we het volgende voorbeeld begrijpen.

Voorbeeld: zonder gebruik van __slots__-attributen

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

Uitvoer -

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

Elk object in Python bevat een dynamisch woordenboek waarmee attributen kunnen worden toegevoegd. Woordenboeken verbruiken veel geheugen, en het gebruik van __slots__ vermindert de verspilling van ruimte en geheugen. Laten we nog een voorbeeld bekijken.

Voorbeeld -

arrays retourneren in Java

 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) 

Uitvoer -

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

In de bovenstaande code hebben we de klasse-attributen geïnitialiseerd met de slots-attributen. De variabele heeft een constante waarde. Als we proberen de variabele opnieuw toe te wijzen, krijgen we een foutmelding.

De @woningdecorateur

Wij kunnen ook gebruiken @eigendom decorateur om een ​​klasse te maken die werkt als naamruimte voor constanten. We hoeven alleen maar de eigenschap constants te definiëren zonder ze een setter-methode te geven. Laten we het volgende voorbeeld begrijpen.

Voorbeeld -

 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) 

Uitvoer -

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

Het zijn slechts alleen-lezen eigenschappen. Als we proberen opnieuw toe te wijzen, krijgen we een AttribuutFout.

De benoemdetuple() fabrieksfunctie

De verzamelmodule van Python wordt geleverd met de fabrieksfunctie genaamd tuple(). De ... gebruiken benoemddubbel() functie, kunnen we de benoemde velden en de puntnotatie gebruiken om toegang te krijgen tot hun items. We weten dat tuples onveranderlijk zijn, wat betekent dat we een bestaand benoemd tuple-object op zijn plaats niet kunnen wijzigen.

Laten we het volgende voorbeeld begrijpen.

Voorbeeld -

 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) 

Uitvoer -

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

De @dataclass-decorateur

Zoals de naam al doet vermoeden, bevat de dataklasse gegevens. Deze kunnen uit methoden bestaan, maar dit is niet hun primaire doel. We moeten de @dataclass-decorateur gebruiken om de gegevensklassen te maken. We kunnen ook de strikte constanten creëren. De @dataclass-decorateur neemt een bevroren argument waarmee we onze dataklasse als onveranderlijk kunnen markeren. De voordelen van het gebruik van @dataclass decorateur: we kunnen het instance-attribuut niet wijzigen.

Laten we het volgende voorbeeld begrijpen.

Voorbeeld -

 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) 

Uitvoer -

 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' 

Uitleg -

In de bovenstaande code hebben we de @dataclass decorateur geïmporteerd. We hebben deze decorateur voor ConstantsName gebruikt om er een dataklasse van te maken. We hebben het bevroren argument ingesteld op True om de gegevensklasse onveranderlijk te maken. We hebben de instantie van de dataklasse gemaakt en we hebben toegang tot alle constanten, maar kunnen ze niet wijzigen.

De speciale methode .__setattr__().

Met Python kunnen we een speciale methode gebruiken genaamd .__setattr__(). Met deze methode kunnen we het attribuuttoewijzingsproces aanpassen, omdat Python de methode automatisch aanroept bij elke attribuuttoewijzing. Laten we het volgende voorbeeld begrijpen -

Voorbeeld -

 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) 

Uitvoer -

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

Met de methode __setattr__() is het niet mogelijk om toewijzingsbewerkingen uit te voeren op de attributen van de klasse. Als we proberen opnieuw toe te wijzen, verhoogt het gewoon een AttribuutFout.

Conclusie

Constanten worden het meest gebruikt in concept bij programmeren, vooral in wiskundige termen. In deze tutorial hebben we geleerd over de belangrijke concepten van de constanten en de smaken ervan. De Python-gemeenschap gebruikt hoofdletters als naamconventie om de constanten te identificeren. We hebben echter enkele geavanceerde manieren besproken om de constanten in Python te gebruiken. We hebben besproken hoe we de leesbaarheid, herbruikbaarheid en onderhoudbaarheid van code kunnen verbeteren met constanten. We hebben besproken hoe we verschillende technieken kunnen toepassen om onze Python-constanten strikt constant te maken.