W tym samouczku dowiemy się o typach stałych i o tym, jak pomagają poprawić czytelność kodu. Jeśli nie jesteś zaznajomiony, stałe to nazwy reprezentujące wartości, które nie zmieniają się podczas wykonywania programu. Są najczęstszym podstawowym pojęciem w programowaniu. Jednak Python nie ma dedykowanej składni do definiowania stałych. Ogólnie rzecz biorąc, stałe Pythona są zmiennymi, które nigdy się nie zmieniają. W nadchodzącej sekcji omówimy szczegółowo stałą Pythona.
Generowanie liczb losowych Java
Co to są stałe?
Ogólnie rzecz biorąc, w matematyce używany jest termin stały, wartość lub ilość, która nigdy się nie zmienia. W programowaniu stała odnosi się do nazwy powiązanej z wartością, która nigdy nie zmienia się podczas wykonywania programowania. Stała programowa różni się od innych stałych i składa się z dwóch rzeczy – nazwy i powiązanej wartości. Nazwa będzie opisywać, o co chodzi w stałej, a wartość jest konkretnym wyrazem samej stałej.
Po zdefiniowaniu stałej mamy dostęp jedynie do jej wartości, ale nie możemy jej zmieniać w czasie. Możemy jednak modyfikować wartość zmiennej. Przykładem z życia wziętym jest: prędkość światła, liczba minut w godzinie i nazwa folderu głównego projektu.
Dlaczego warto używać stałej?
W językach programowania stałe pozwalają nam chronić przed przypadkową zmianą ich wartości, co może powodować trudne do debugowania błędy. Pomocne jest również uczynienie kodu bardziej czytelnym i łatwym w utrzymaniu. Zobaczmy zalety stałej.
Stałe zdefiniowane przez użytkownika
Aby zdefiniować stałą w Pythonie, musimy użyć konwencji nazewnictwa w Pythonie. Nazwę powinniśmy pisać wielkimi literami z podkreśleniami oddzielającymi wyrazy.
Poniżej znajdują się przykłady stałych Pythona zdefiniowanych przez użytkownika -
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', ... ]
Użyliśmy tego samego sposobu, w jaki tworzymy zmienne w Pythonie. Możemy więc założyć, że stałe Pythona są po prostu zmiennymi, a jedyną różnicą jest to, że stała używa wyłącznie wielkich liter.
Używanie wielkich liter sprawia, że stała wyróżnia się na tle naszych zmiennych i jest użyteczną lub preferowaną praktyką.
Powyżej omówiliśmy użytkowników zdefiniowanych przez użytkownika; Python udostępnia także kilka nazw wewnętrznych, które można traktować jako stałe i które należy traktować jako stałe.
Ważne stałe w Pythonie
W tej sekcji dowiemy się o niektórych stałych wewnętrznych, które służą do zwiększenia czytelności kodu Pythona. Rozumiemy kilka ważnych stałych.
Wbudowane stałe
W oficjalnej dokumentacji PRAWDA I FAŁSZ są wymienione jako pierwsza stała. Są to wartości logiczne Pythona i są instancją int. A PRAWDA ma wartość 1, oraz FAŁSZ ma wartość 0.
Przykład -
>>> 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
Pamiętaj, że nazwy Prawda i Fałsz są stałymi stałymi. Innymi słowy, nie możemy ich ponownie przypisać, a jeśli spróbujemy je ponownie przypisać, otrzymamy błąd składniowy. Te dwie wartości są obiektami singleton w Pythonie, co oznacza, że istnieje tylko jedna instancja.
Wewnętrzne nazwy Dunder
Python ma również wiele wewnętrznych grzmot nazwy, które możemy uważać za stałe. Istnieje kilka takich unikalnych nazw. O __name__ i __file__ dowiemy się w tej sekcji.
Atrybut __name__ jest powiązany ze sposobem uruchomienia danego fragmentu kodu. Podczas importowania modułu Python wewnętrznie ustawia __name__ na ciąg zawierający nazwę modułu.
nowy_plik.py
print(f'The type of __name__ is: {type(__name__)}') print(f'The value of __name__ is: {__name__}') W wierszu poleceń i wpisz następujące polecenie -
python -c 'import new_file'
Opcja -c służy do wykonania małego fragmentu kodu Pythona w wierszu poleceń. W powyższym przykładzie zaimportowaliśmy plik nowy plik moduł, który wyświetla niektóre komunikaty na ekranie.
Wyjście -
The type of __name__ is: The value of __name__ is: timezone
Jak widzimy, że __name__ przechowuje ciąg __main__, oznacza to, że możemy uruchomić pliki wykonywalne bezpośrednio jako program w języku Python.
Z drugiej strony atrybut __file__ zawiera plik, który Python aktualnie importuje lub wykonuje. Jeżeli wewnątrz pliku użyjemy atrybutu __file__ to otrzymamy ścieżkę do samego modułu.
Zobaczmy następujący przykład -
Przykład -
wyrażenia lambda w Javie
print(f'The type of __file__ is: {type(__file__)}') print(f'The value of __file__ is: {__file__}') Wyjście:
The type of __file__ is: The value of __file__ is: D:Python Project ew_file.py
Możemy również uruchomić bezpośrednio i uzyskamy ten sam wynik.
Przykład -
print(f'The type of __file__ is: {type(__file__)}') print(f'The value of __file__ is: {__file__}') Wyjście:
python new_file.py The type of __file__ is: The value of __file__ is: timezone.py
Przydatne ciągi znaków i stałe matematyczne
W bibliotece standardowej znajduje się wiele cennych stałych. Niektóre są ściśle powiązane z konkretnymi modułami, funkcjami i klasami; wiele z nich ma charakter ogólny i możemy ich używać w kilku scenariuszach. W poniższym przykładzie użyjemy odpowiednio modułów math i string związanych z ciągami znaków.
Rozumiemy następujący przykład -
Przykład -
>>> 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
Stałe te będą odgrywać istotną rolę, gdy będziemy pisać kod matematyczny lub wykonywać określone obliczenia.
Rozumiemy następujący przykład -
menu ustawień Androida
Przykład -
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})' W powyższym kodzie użyliśmy metody matematyka.pi zamiast niestandardowego Liczba Pi stałe. Stała matematyczna zapewnia programowi więcej kontekstów. Zaletą stosowania stałej math.pi jest to, że jeśli używamy starszej wersji Pythona, otrzymamy 32-bitową wersję Pi. Jeśli użyjemy powyższego programu we współczesnej wersji Pythona, otrzymamy 64-bitową wersję pi. Zatem nasz program sam dostosuje się do konkretnego środowiska wykonawczego.
Moduł string udostępnia również przydatne wbudowane stałe łańcuchowe. Poniżej znajduje się tabela nazw i wartości każdej stałej.
| Nazwa | Wartość |
|---|---|
| ascii_małe litery | ABCDEFGHIJKLMNOPQRSTU VWXYZ |
| ascii_wielkie litery | ABCDEFGHIJKLMNOPQRSTU VWXYZ |
| ascii_lettery | ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz |
| cyfry | 0123456789 |
| cyfry szesnastkowe | 0123456789abcdefABCDEF |
| cyfry ósemkowe | 01234567 |
Możemy używać tych stałych związanych z ciągami znaków w wyrażeniach regularnych, przetwarzaniu języka naturalnego, przy dużym przetwarzaniu ciągów i nie tylko.
Stałe opisujące typ
Od wersji Python 3.8 moduł pisania zawiera klasę Final, która pozwala nam dodawać adnotacje do stałych. Jeśli użyjemy klasy Final do zdefiniowania stałych w programie, otrzymamy błąd typu statycznego, który sprawdza moduł sprawdzania mypy i pokaże, że nie możemy ponownie przypisać nazwy Final. Rozumiemy następujący przykład.
Przykład -
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)
Określiliśmy stałą zmienną z klasą końcową, która wskazywała błąd typu, aby zgłosić błąd w przypadku ponownego przypisania zadeklarowanej nazwy. Jednakże otrzymuje raport o błędzie modułu sprawdzania typu; Python zmienia wartość MAX_SPEED. Zatem Final nie zapobiega ciągłemu przypadkowemu ponownemu przypisaniu w czasie wykonywania.
Stałe łańcuchowe
Jak omówiono we wcześniejszej sekcji, Python nie obsługuje ścisłych stałych; ma po prostu zmienne, które nigdy się nie zmieniają. Dlatego społeczność Pythona przestrzega konwencji nazewnictwa polegającej na używaniu wielkich liter do identyfikacji zmiennych stałych.
Może to stanowić problem, jeśli pracujemy nad dużym projektem w Pythonie z wieloma programistami na różnych poziomach. Zatem dobrą praktyką byłoby posiadanie mechanizmu umożliwiającego stosowanie ścisłych stałych. Jak wiemy, Python jest językiem dynamicznym i istnieje kilka sposobów na uczynienie stałych niezmienialnymi. W tej sekcji dowiemy się o niektórych z tych sposobów.
Atrybuty .__slots__
Klasy Pythona umożliwiają korzystanie z atrybutów __slots__. Szczelina posiada specjalny mechanizm pozwalający na zmniejszenie rozmiaru obiektów. Jest to koncepcja optymalizacji pamięci obiektów. Jeśli użyjemy w klasie atrybutu __slots__, nie będziemy mogli dodać nowej instancji, ponieważ nie używa ona atrybutów __dict__. Dodatkowo brak posiadania .__dykt__ atrybut implikuje optymalizację pod względem zużycia pamięci. Rozumiemy następujący przykład.
Przykład - bez użycia atrybutów __slots__
class NewClass(object): def __init__(self, *args, **kwargs): self.a = 1 self.b = 2 if __name__ == '__main__': instance = NewClass() print(instance.__dict__)
Wyjście -
połączenie pd
{'a': 1, 'b': 2} Każdy obiekt w Pythonie zawiera dynamiczny słownik umożliwiający dodawanie atrybutów. Słowniki zużywają dużo pamięci, a użycie __slotów__ zmniejsza marnotrawstwo miejsca i pamięci. Zobaczmy inny przykład.
Przykład -
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)
Wyjście -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 10, in AttributeError: 'ConstantsName' object attribute 'PI' is read-only
W powyższym kodzie zainicjowaliśmy atrybuty klasy atrybutami slotów. Zmienna ma stałą wartość, jeśli spróbujemy ponownie przypisać zmienną, otrzymamy błąd.
Dekorator @property
Możemy również skorzystać @nieruchomość dekorator, aby utworzyć klasę, która działa jako przestrzeń nazw dla stałych. Musimy tylko zdefiniować właściwość stałych bez udostępniania im metody ustawiającej. Rozumiemy następujący przykład.
Przykład -
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)
Wyjście -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 13, in AttributeError: can't set attribute
Są to po prostu właściwości tylko do odczytu, jeśli spróbujemy ponownie przypisać, otrzymamy Błąd atrybutu.
Funkcja fabryczna nazwanatuple().
Moduł kolekcji Pythona jest wyposażony w funkcję fabryczną o nazwie Nametuple(). Używając nazwana krotka() funkcji, możemy użyć nazwanych pól i notacji kropkowej, aby uzyskać dostęp do ich elementów. Wiemy, że krotki są niezmienne, co oznacza, że nie możemy w miejscu modyfikować istniejącego nazwanego obiektu krotki.
Rozumiemy następujący przykład.
Przykład -
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)
Wyjście -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 17, in AttributeError: can't set attribute
Dekorator @dataclass
Jak sama nazwa wskazuje, klasa danych przechowuje dane, mogą składać się z metod, ale nie jest to ich główny cel. Aby utworzyć klasy danych, musimy użyć dekoratora @dataclass. Możemy również utworzyć ścisłe stałe. Dekorator @dataclass przyjmuje zamrożony argument, który pozwala nam oznaczyć naszą klasę danych jako niezmienną. Zalety korzystania z dekoratora @dataclass polegają na tym, że nie możemy modyfikować jego atrybutu instancji.
Rozumiemy następujący przykład.
Wyczyść pamięć podręczną npm
Przykład -
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)
Wyjście -
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'
Wyjaśnienie -
W powyższym kodzie zaimportowaliśmy dekorator @dataclass. Użyliśmy tego dekoratora do ConstantsName, aby uczynić go klasą danych. Ustawiamy zamrożony argument na True, aby klasa danych była niezmienna. Stworzyliśmy instancję klasy danych i mamy dostęp do wszystkich stałych, ale nie możemy ich modyfikować.
Metoda specjalna .__setattr__().
Python umożliwia nam użycie specjalnej metody zwanej .__setattr__(). Korzystając z tej metody, możemy dostosować proces przypisywania atrybutów, ponieważ Python automatycznie wywołuje tę metodę przy każdym przypisaniu atrybutu. Rozumiemy następujący przykład -
Przykład -
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) Wyjście -
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__() nie pozwala na wykonanie żadnej operacji przypisania na atrybutach klasy. Jeśli spróbujemy zmienić przypisanie, po prostu podnosimy an Błąd atrybutu.
Wniosek
Stałe są najczęściej używane w koncepcji programowania, zwłaszcza w terminologii matematycznej. W tym samouczku poznaliśmy ważne pojęcia stałych i ich smaków. Społeczność Pythona używa wielkich liter jako konwencji nazw do identyfikacji stałych. Jednakże omówiliśmy kilka zaawansowanych sposobów używania stałych w Pythonie. Omówiliśmy, jak poprawić czytelność, możliwość ponownego użycia i łatwość konserwacji kodu za pomocą stałych. Wspomnieliśmy, jak zastosować różne techniki, aby nasze stałe Pythona były ściśle stałe.