В този урок ще научим за пространството от имена в Python, структурата, използвана за организиране на символните имена, присвоени на обекти в програма на Python, защо пространството от имена е важно и как можем да ги използваме в нашата програма на Python. Нека направим кратко въведение в пространството от имена.
Какво е пространство от имена?
В Python начин да се даде уникално име на всеки обект е чрез пространство от имена. Променливите и методите са примери за обекти в Python. Казано по друг начин, това е колекция от известни символични имена и подробности за нещото, за което се отнася всяко име. Името може да се разглежда като ключ в речник, а обектите са стойностите в пространството от имена. Трябва да го разберем с истински модел - пространството от имена прилича на фамилия. Ако има няколко имена „Петър“ в класа, може да е трудно да се намери име „Петър“; обаче, когато изрично поискаме „Питър Уорнър“ или „Питър Куминс“, в клас може да не е обичайно няколко ученици да имат едно и също име и фамилия.
Интерпретаторът на Python може да разбере по-добре точния метод или променлива в кода благодарение на пространството от имена. В резултат на това името му съдържа допълнителна информация, включително пространство (свързано с обхвата) и име, което обозначава уникален идентификатор.
В Python има четири типа пространства от имена, които са дадени по-долу.
- Вградена
- Глобален
- Ограждащи
- Местен
Тъй като тези различни пространства от имена имат живот, интерпретаторът на Python създава пространства от имена, ако е необходимо, и ги изтрива, когато вече не са необходими.
Нека разберем различните типове пространство от имена в Python.
Вграденото пространство от имена
Както подсказва името му, той съдържа предварително дефинирани имена на всички вградени обекти на Python, които вече са налични в Python. Нека изброим тези имена със следната команда.
Отворете терминала на Python и въведете следната команда.
команда -
dir(__builtins__)
Изход:
['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']
Вграденото пространство от имена се създава от интерпретатора на Python, когато се стартира. Те се прекратяват при прекратяване на интерпретатора на Python.
Глобалното пространство на имената
Глобалното пространство от имена се състои от всякакви имена в Python на всяко ниво на основната програма. Създава се, когато основното тяло се изпълни и остава да съществува, докато интерпретаторът прекрати работа.
Интерпретаторът на Python създава глобално пространство от имена за всеки модул, който нашият Python зарежда с инструкцията за импортиране. За да получите повече информация, посетете нашия Python модул.
Локалните и обхващащите пространства от имена
Локалните пространства от имена се използват от функцията; Когато функцията се изпълнява, интерпретаторът на Python създава ново пространство от имена. Локалните пространства от имена продължават да съществуват, след като функцията приключи. Способността може също така да се състои от друга способност. Както е показано по-долу, можем да дефинираме една функция в друга.
пример -
def f(): print('Initiate f()') def g(): print('Initiate g()') print('End g()') return g() print('Initiate f()') return f()
В горния модел възможността g() се характеризира вътре в колекцията от f(). Извикахме функцията g() в рамките на f() и основната функция f(). Нека да разгледаме как работи горната функция:
- Python създава ново пространство от имена за f(), когато го извикаме.
- По същия начин f() извиква g(), g() получава свое собствено различно пространство от имена.
- Локалното пространство от имена g() е създадено за обхващащото пространство от имена, f().
Всяко от тези пространства от имена се прекратява, когато функцията се прекратява.
Обхват на обекта/променливата
Терминът „обхват“ указва до коя област на кодиране на конкретен обект на Python може да бъде достъпен. Всеки обект и променлива има обхват в програмата, от който можем да осъществим достъп до тази променлива. Например функционална променлива може да бъде достъпна само в рамките на функцията. Нека разгледаме следната илюстрация:
пример -
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()
Изход:
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
Речници на пространството от имена на Python
В предишния урок говорихме как пространствата от имена са като речници, с ключове, представляващи имена на обекти, и стойности, представляващи действителни обекти. Като речници Python използва както глобални, така и локални пространства от имена. Достъпът до глобални и локални речници на пространството от имена е възможен чрез методите globals() и locals() на Python.
Методът globals().
Методът globals() връща препратка към текущия глобален речник на пространството от имена. Можем да го използваме за достъп до обектите в глобалното пространство от имена. Нека видим примера по-долу.
пример -
jpa срещу хибернация
>>> type(globals()) >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': } Както виждаме, има много вградени записи глобални () метод. Може да се различава в зависимост от вашата операционна система и версията на Python. Сега нека дефинираме глобалната променлива и да наблюдаваме разликите.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} След присвояването на a = 20, нова глобална променлива, присвоена на глобалния речник на пространството от имена. Имаме достъп до стойностите, както имаме достъп до речниците. Нека видим примера по-долу.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} >>> a 20 >>> globals()['a'] 20 Можем да променим стойността на речника с помощта на функцията globals().
>>> globals()['a'] = 100 >>> a 100
Сега новата стойност на a ще се появи в глобалните речници.
Функцията locals().
Python също предоставя метода locals(), подобен на globals(), но вместо това има достъп до обекти в локалното пространство от имена. Да видим следния пример.
пример -
>>> def func(a, b): ... str1 = 'Hello' ... loc = locals() ... print(loc) ... >>> func(10, 20) {'a': 10, 'b': 20, 'str1': 'Hello'} Когато извикаме func(10, 20), locals() връща речника, представляващ локалното пространство от имена на функцията. В обхвата на функцията дефинирахме локалната променлива str1; локалното пространство от имена включваше аргументите на функцията, тъй като те са локални за func().
Независимо от това, когато наричаме способността local people(), тя действа еквивалентно на способността globals(). Функцията globals() и функцията locals() се различават леко. Функцията globals() не само дефинира допълнителни променливи, но също така съхранява върнатата стойност. Речникът ще съдържа новите променливи и техните стойности. Разгледайте примера по-долу.
пример -
>>> 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'} Тук glob_var е препратка към глобалния речник на пространството от имена. Новите изявления за задание х и и се появи в glob_var речник.
Промяна на променливи извън обхвата
В извикващата среда функцията може да промени аргумента, като подаде различна стойност, но понякога не може да промени стойността.
Неизменен аргумент не може да бъде модифициран от функция.
Променлив аргумент може да бъде променен на място, но не може да бъде напълно предефиниран.
Нека разберем следния сценарий.
пример -
x = 20 def func(): x = 40 print(x) func() print(x)
Изход:
40 20
Дефинираме глобална променлива x = 20 и също във функция със същото име. Когато func() се изпълни, той създава препратка към нова локална променлива към целочислен обект, чиято стойност е 40. Вътре в функция () тяло, операторът за присвояване няма да засегне глобалния обект.
Функция обаче може да модифицира обект от променлив тип извън своя локален обхват. Нека разберем примера по-долу.
пример -
my_list = ['Hello', 'From', 'JavaTpoint'] def func(): my_list[1] = 'Welcome to' return my_list print(func())
my_list е списък и е променлив тип. Func() може да променя вътре в my_list, въпреки че е извън локалния обхват. Но ако се опитаме да преназначим my_list, той ще създаде нов локален обект и няма да промени глобалния my_list. Нека видим примера по-долу.
пример -
my_list = ['Hello', 'from', 'JavaTpoint'] def func(): my_list = ['A', 'B', 'C', 'D', 'E', ''] return my_list print(func())
Изход:
['A', 'B', 'C', 'D', 'E']
Заключение
Ние се грижим за пространството на имената, как можем да го използваме и степента на променливата. Множество отделни обекти могат да бъдат създадени с кратка програма на Python. Този брой може да надхвърли хиляда в сложна програма на Python. Пространството от имена на Python улеснява интерпретатора да запомни имената на тези обекти.
анализиране на низ към int