W tym samouczku dowiemy się o przestrzeni nazw w Pythonie, strukturze używanej do organizowania nazw symbolicznych przypisanych do obiektów w programie w Pythonie, dlaczego przestrzeń nazw jest ważna i jak możemy ich używać w naszym programie w Pythonie. Oto krótkie wprowadzenie do przestrzeni nazw.
Co to jest przestrzeń nazw?
W Pythonie sposobem na nadanie każdemu obiektowi unikalnej nazwy jest użycie przestrzeni nazw. Zmienne i metody są przykładami obiektów w Pythonie. Inaczej mówiąc, jest to zbiór znanych nazw symbolicznych i szczegółów dotyczących rzeczy, do której każda nazwa się odnosi. Nazwę można traktować jak klucz w słowniku, a obiekty to wartości w przestrzeni nazw. Powinniśmy to rozpracować na podstawie prawdziwego modelu – przestrzeń nazw przypomina nazwisko. Jeśli w klasie jest wiele imion „Piotr”, znalezienie imienia „Piotr” może być trudne; jednakże, gdy specjalnie poprosimy o „Peter Warner” lub „Peter Cummins”, w klasie może nie być powszechne, że wielu uczniów ma to samo imię i nazwisko.
Interpreter Pythona może lepiej zrozumieć dokładną metodę lub zmienną w kodzie dzięki przestrzeni nazw. Dzięki temu jego nazwa zawiera dodatkowe informacje, m.in. Spację (związaną z zakresem) oraz Nazwę, która oznacza unikalny identyfikator.
W Pythonie istnieją cztery typy przestrzeni nazw, które podano poniżej.
- Wbudowany
- Światowy
- Załączając
- Lokalny
Ponieważ te przestrzenie nazw mają swój okres istnienia, interpreter Pythona tworzy przestrzenie nazw w razie potrzeby i usuwa je, gdy nie są już potrzebne.
Przyjrzyjmy się różnym typom przestrzeni nazw w Pythonie.
Wbudowana przestrzeń nazw
Jak sama nazwa wskazuje, zawiera predefiniowane nazwy wszystkich wbudowanych obiektów Pythona, które są już dostępne w Pythonie. Wypiszmy te nazwy za pomocą następującego polecenia.
Otwórz terminal Pythona i wpisz następujące polecenie.
Komenda -
dir(__builtins__)
Wyjście:
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
Wbudowana przestrzeń nazw jest tworzona przez interpreter Pythona podczas jego uruchamiania. Są one kończone wraz z zakończeniem działania interpretera Pythona.
Globalna przestrzeń nazw
Globalna przestrzeń nazw składa się z dowolnych nazw w Pythonie na dowolnym poziomie programu głównego. Jest tworzony, gdy główna część jest wykonywana i pozostaje istniejąca do zakończenia działania interpretera.
Interpreter Pythona tworzy globalną przestrzeń nazw dla dowolnego modułu, który nasz Python ładuje za pomocą instrukcji import. Aby uzyskać więcej informacji, odwiedź nasz moduł Python.
Lokalne i otaczające przestrzenie nazw
Funkcja używa lokalnych przestrzeni nazw; Po uruchomieniu funkcji interpreter języka Python tworzy nową przestrzeń nazw. Lokalne przestrzenie nazw nadal istnieją po zakończeniu działania funkcji. Zdolność może również obejmować inną zdolność. Jak pokazano poniżej, możemy zdefiniować jedną funkcję w ramach drugiej.
Przykład -
def f(): print('Initiate f()') def g(): print('Initiate g()') print('End g()') return g() print('Initiate f()') return f()
W powyższym modelu zdolność g() scharakteryzowana jest wewnątrz zbioru f(). Funkcję g() wywołaliśmy w obrębie funkcji f() i głównej funkcji f(). Przyjrzyjmy się, jak działa powyższa funkcja:
- Python tworzy nową przestrzeń nazw dla funkcji f(), gdy ją wywołujemy.
- Podobnie f() wywołuje g(), g() otrzymuje własną, inną przestrzeń nazw.
- Utworzono lokalną przestrzeń nazw g() dla otaczającej ją przestrzeni nazw f().
Każda z tych przestrzeni nazw kończy się wraz z zakończeniem funkcji.
Zakres obiektu/zmiennej
Termin „zakres” określa, do jakiego regionu kodowania konkretnego obiektu Pythona można uzyskać dostęp. Każdy obiekt i zmienna ma w programie zakres, z którego możemy uzyskać dostęp do tej zmiennej. Na przykład dostęp do zmiennej funkcji można uzyskać tylko w obrębie funkcji. Przeanalizujmy następującą ilustrację:
Przykład -
def scope_func(): print('Inside scope_func') def scope_inner_func(): var = 20 print('Inside inner function, value of var:',var) scope_inner_func() print('Try printing var from outer function: ',var) scope_func()
Wyjście:
Inside scope_func Inside inner function, value of var: 20 Traceback (most recent call last): File 'd:/Python Project/listproblems.py', line 343, in scope_func() File 'd:/Python Project/listproblems.py', line 342, in scope_func print('Try printing var from outer function: ',var) NameError: name 'var' is not defined
Słowniki przestrzeni nazw Pythona
W poprzednim samouczku mówiliśmy o tym, że przestrzenie nazw przypominają słowniki, w których klucze reprezentują nazwy obiektów, a wartości reprezentują rzeczywiste obiekty. Jako słowniki Python używa zarówno globalnych, jak i lokalnych przestrzeni nazw. Dostęp do globalnych i lokalnych słowników przestrzeni nazw jest możliwy dzięki metodom globals() i locals() języka Python.
Metoda globals().
Metoda globals() zwraca odwołanie do bieżącego słownika globalnej przestrzeni nazw. Możemy go użyć, aby uzyskać dostęp do obiektów w globalnej przestrzeni nazw. Zobaczmy poniższy przykład.
Przykład -
>>> type(globals()) >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': } Jak widzimy, istnieje wiele wbudowanych wpisów globale() metoda. Może się różnić w zależności od systemu operacyjnego i wersji Pythona. Zdefiniujmy teraz zmienną globalną i obserwujmy różnice.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} Po przypisaniu a = 20, nowa zmienna globalna przypisana do słownika globalnej przestrzeni nazw. Dostęp do wartości możemy uzyskać w taki sam sposób, w jaki uzyskujemy dostęp do słowników. Zobaczmy poniższy przykład.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} >>> a 20 >>> globals()['a'] 20 Możemy modyfikować wartość słownika za pomocą funkcji globals().
>>> globals()['a'] = 100 >>> a 100
Teraz w słownikach globalnych pojawi się nowa wartość a.
Funkcja locals().
Python udostępnia również metodę locals() podobną do globals(), ale zamiast tego uzyskuje dostęp do obiektów w lokalnej przestrzeni nazw. Zobaczmy następujący przykład.
Przykład -
>>> def func(a, b): ... str1 = 'Hello' ... loc = locals() ... print(loc) ... >>> func(10, 20) {'a': 10, 'b': 20, 'str1': 'Hello'} Kiedy wywołujemy funkcję func(10, 20), funkcja locals() zwraca słownik reprezentujący lokalną przestrzeń nazw funkcji. W zakresie funkcji zdefiniowaliśmy zmienną lokalną str1; lokalna przestrzeń nazw zawierała argumenty funkcji, ponieważ są one lokalne dla funkcji func().
Niezależnie od tego, gdy wywołujemy funkcję local People(), działa ona tak samo jak funkcja globals(). Funkcja globals() i funkcja locals() różnią się nieco. Funkcja globals() nie tylko definiuje dodatkowe zmienne, ale także przechowuje wartość zwracaną. Słownik będzie zawierał nowe zmienne i ich wartości. Spójrz na poniższy przykład.
format daty.format
Przykład -
>>> glob_var = globals() >>> glob_var {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 100, 'func': , 'glob_var': {...}, 'x': 100, 'y': 'JavaTpoint'} >>> x = 100 >>> glob_var {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 100, 'func': , 'glob_var': {...}, 'x': 100, 'y': 'JavaTpoint'} Tutaj global_var jest odniesieniem do słownika globalnej przestrzeni nazw. Nowe instrukcje przypisania X I I pojawił się w global_var słownik.
Zmiana zmiennych poza zakresem
W środowisku wywołującym funkcja może zmienić argument, przekazując inną wartość, ale czasami nie może zmienić wartości.
Niezmienny argument nie może być modyfikowany przez funkcję.
Zmienny argument można zmienić w miejscu, ale nie można go całkowicie przedefiniować.
Rozumiemy następujący scenariusz.
Przykład -
x = 20 def func(): x = 40 print(x) func() print(x)
Wyjście:
40 20
Definiujemy zmienną globalną x = 20, a także funkcję o tej samej nazwie. Kiedy funkcja func() jest wykonywana, tworzy nową zmienną lokalną odwołanie do obiektu całkowitego, którego wartość wynosi 40. Wewnątrz funkcja() body, instrukcja przypisania nie będzie miała wpływu na obiekt globalny.
Jednakże funkcja może modyfikować obiekt typu modyfikowalnego poza swoim zasięgiem lokalnym. Rozumiemy poniższy przykład.
Przykład -
my_list = ['Hello', 'From', 'JavaTpoint'] def func(): my_list[1] = 'Welcome to' return my_list print(func())
my_list jest listą i można ją modyfikować. Funkcja func() może modyfikować zawartość my_list, nawet jeśli znajduje się ona poza zasięgiem lokalnym. Jeśli jednak spróbujemy ponownie przypisać my_list, utworzymy nowy obiekt lokalny i nie zmodyfikujemy globalnej my_list. Zobaczmy poniższy przykład.
Przykład -
my_list = ['Hello', 'from', 'JavaTpoint'] def func(): my_list = ['A', 'B', 'C', 'D', 'E', ''] return my_list print(func())
Wyjście:
['A', 'B', 'C', 'D', 'E']
Wniosek
Dbamy o przestrzeń nazw, sposób jej wykorzystania i stopień zmiennej. Za pomocą krótkiego programu w języku Python można utworzyć wiele odrębnych obiektów. W skomplikowanym programie w języku Python liczba ta może przekroczyć tysiąc. Przestrzeń nazw Pythona ułatwia interpreterowi zapamiętanie nazw tych obiektów.