Рубрики
Без рубрики

Переменная Python – определить, печать, область, удаление, лучшие практики

Переменные Python являются идентификаторами для ссылки на объект. Узнайте о Python Variable Декларацию, переменные печати, типов, объем переменной Python, переменную удаления.

Автор оригинала: Pankaj Kumar.

Переменная Python – это идентификатор для ссылки на значение в программе. Переменная содержит местоположение памяти объекта. Они позволяют Python Program для доступа к другим объектам и вызывают свои функции или выполнять другие операции.

Правила для определения переменной Python

Есть несколько правил, чтобы определить переменную Python.

  1. Имя переменной Python может содержать небольшие буквы (A-Z), заглавные буквы (A-Z), цифры (0-9) и подчеркивание (_).
  2. Имя переменной не может начать с номера.
  3. Мы не можем использовать зарезервированные Ключевые слова как имя переменной.
  4. Переменная Python не может содержать только цифры.
  5. Имя переменной Python может начать с подчеркивания или буквы.
  6. Имена переменной чувствительны к регистру.
  7. Нет предела на длине имена переменной.

Python Допустимые переменные Примеры

  • азбука
  • _ : Да, мы можем создать имя переменной как подчеркивание.
  • __ : Да, множественные подчеркивания также являются допустимым именем переменной.
  • x_yab.
  • _abc.

Python Неверные примеры переменных

  • 9abc : имя переменной не может начать с номера.
  • 123 : имя переменной не может содержать только цифры.
  • x-y : Единственный специальный символ, разрешенный в имени переменного, является подчеркиванием.
  • def : Неверное имя переменной, потому что это зарезервированное ключевое слово.

Как объявить переменную в Python?

Python – это динамически напечатанный язык. Нам не нужно указывать тип переменной при его объявлении. Переменная Python определяется с равным признаком. Левая часть содержит имя переменной, а правую часть содержит значение переменной.

Давайте посмотрим на несколько примеров, чтобы объявить переменную в Python.

x = 1  # number
s = "Hello"  # string
t = (1, 2)  # tuple
l = [1, 2, 3]  # list
d = {"1": "A", "2": "B"}  # dictionary

Python также поддерживает многократное задание. Мы можем определить несколько переменных сразу, используя несколько заданий.

a = b = c = 100
print(a, b, c)  # 100 100 100

Мы также можем назначить последовательность в список переменных. В этом случае количество элементов в последовательности должно быть равно количеству переменных.

a, b, c = 1, 2, "Hello"
print(a, b, c)  # 1 2 Hello

a, b, c = (1, 2, 3)
print(a, b, c)  # 1 2 3

a, b, c = [1, 2, 3]
print(a, b, c)  # 1 2 3

a, b, c = "098"
print(a, b, c)  # 0 9 8

Посмотрим, что произойдет, когда количество переменных и количество элементов в последовательности не равно.

>>> a,b = (1,2,3)
Traceback (most recent call last):
  File "", line 1, in 
ValueError: too many values to unpack (expected 2)
>>> 
>>> a,b,c,d = (1,2,3)
Traceback (most recent call last):
  File "", line 1, in 
ValueError: not enough values to unpack (expected 4, got 3)
>>>

Как распечатать вариабельное значение в Python?

Мы можем использовать функцию Python Print () для печати значения переменной. Давайте посмотрим на некоторые примеры для печати значений переменных в Python.

x = 1  # number
print(x)
s = "Hello"  # string
print("s value is", s)
t = (1, 2)  # tuple
print("tuple value is", t)
l = [1, 2, 3]  # list
print(l)
d = {"1": "A", "2": "B"}  # dictionary
print("dict value is", d)
Переменная Python Print.

Программы Python выполняются последовательно. Так что если вы попытаетесь получить доступ к переменной, прежде чем она определится, вы получите NameError Отказ

print(count)  # NameError: name 'count' is not defined

count = 100

print(count)  # 100

Лучшие практики для имени переменной Python

Если вы посмотрите на вышеуказанные фрагменты кода, имена переменных являются случайными. Они не передают значение переменных. Есть несколько лучших практик, чтобы следовать при названии переменной в Python.

  1. Используйте только несколько букв, цифр и подчеркивание имени переменной Python.
  2. Если имя переменной имеет несколько слов, вы можете разделить их с помощью подчеркивания.
  3. Если вариабельная область имеет приватную, то вы можете начать его имя с подчеркиванием.
  4. Вам следует избегать переменной имен, начинающих и заканчивающихся подчеркиванием. Они используются в потрачении встроенные программы Python.
  5. Всегда используйте значимое имя для переменной. Он должен передавать тип данных и предполагаемое использование переменной.
  6. Длина имени переменной не имеет предела. Но хорошо иметь небольшие и значимые имена.

На основании вышеупомянутых лучших практик мы можем изменить вышеуказанный фрагмент кода, чтобы иметь правильные имена переменной.

count = 1
str_message = "Hello"
tuple_ints = (1, 2)
list_of_numbers = [1, 2, 3]
numbers_letters_dict = {"1": "A", "2": "B"}

Как распечатать тип переменной?

Мы не указываем тип переменной в программах Python. Мы можем использовать Тип () Функция для определения типа переменной. Давайте посмотрим на некоторые примеры для печати типа переменной.

count = 1  # number
print(type(count))
str_message = "Hello"  # string
print("str_message type is", type(str_message))
tuple_ints = (1, 2)  # tuple
print("tuple_ints type is", type(tuple_ints))
list_of_numbers = [1, 2, 3]  # list
print(type(list_of_numbers))
numbers_letters_dict = {"1": "A", "2": "B"}  # dictionary
print("numbers_letters_dict type is", type(numbers_letters_dict))

Выход:


str_message type is 
tuple_ints type is 

numbers_letters_dict type is

Каковы различные типы переменной в Python

Тип переменной Python – это тип данных его значения. Python – это объектно-ориентированный язык программирования. Все в Python – это объект. Итак, переменные Python всегда являются экземпляром класса.

  • х Здесь тип переменной «X» – «int». Он имеет отношение к экземпляру класса INT.
  • сообщение : Тип переменной сообщения «STR».

Python переменная спецификация

Переменная область охвата определяет область доступности переменной в программе. Переменные Python имеют два спецификация.

  1. Местный спектр
  2. Глобальный спектр

Python локальная переменная

Когда переменная определяется внутри функции или класса, то она доступна только внутри него. Они называются локальными переменными, и их объем ограничен только этой функцией или границей класса.

Если мы попытаемся получить доступ к локальной переменную за пределами его объема, мы получаем NameError что переменная не определена.

Давайте понять идею локальной переменной Python с некоторыми примерами.

def foo():
    foo_var = 1
    print(foo_var)


foo()
print(foo_var)
Python локальная переменная область
  • Печать () внутри foo () Функция может получить доступ к foo_var Потому что это внутри его объема.
  • Печать () вне foo () Функция не может получить доступ к foo_var Потому что это выходит из объема переменной.

Давайте посмотрим на другой пример для локальной переменной, определенной внутри класса. Переменная область имеет класс для этого сценария.

class Foo:
    class_foo_var = 1

print(class_foo_var)

Выход : NameError: Имя 'class_foo_var' не определен

Python Global Rivable.

Когда переменная не находится внутри функции или класса, это доступно из любой точки программы. Эти переменные называются глобальными переменными. Давайте посмотрим на примеры Python Global Variable.

global_msg = "Hello"


def foo():
    print(global_msg)  # global variables are accessible inside a function


class Foo:
    print(global_msg)  # global variables are accessible inside a class


if 5 < 10:
    print(global_msg)  # global variables are accessible inside a code block

Переменные, определенные внутри блоков кода, такие как, если бы и другие, для петли, в то время как цикла, попробуйте, кроме и т. Д., Добавляют в глобальную область, при условии, что код объявления переменной был выполнен. Давайте понять это простым примером.

>>> if True:
...     var_if = "if"
... else:
...     var_else = "else"
... 
>>> 
>>> print(var_if)
if
>>> print(var_else)
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'var_else' is not defined
>>>

VAR_ELSE не определяется, поскольку код внутри остального блока не выполнил.

Давайте посмотрим на другой пример с блок TRY – кроме блока.

>>> try:
...     var_try = "try"
...     raise TypeError('explicitly throwing')
... except:
...     var_except = "except"
... 
>>> print(var_try)
try
>>> print(var_except)
except
>>>

Мы можем получить доступ к переменным, определенным внутри попытки, кроме блока, потому что они оба были выполнены.

Удаление переменной Python

Мы можем удалить переменную, используя дель утверждение. Давайте посмотрим на простой пример, чтобы удалить переменную Python.

>>> count = 100
>>> print(count)
100
>>> del count
>>> 
>>> print(count)
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'count' is not defined
>>>

Python статическая переменная

Переменные, определенные внутри класса, могут быть доступны с именем класса. Они также называют статическими переменными, потому что они принадлежат к классу.

class Data:
    id = 0


print(Data.id)  # static access

Эти переменные могут быть доступны от объекта класса. Тем не менее, доступ к статистическому использованию класса является рекомендуемым образом.

d1 = Data()

print(d1.id)  # class variable accessed from object

Быстрое слово на глобальных функциях () и местных жителей ()

  • Функция Python Globals () Возвращает словарь текущих областей глобальных переменных.
  • Функция Python Locals () Возвращает словарь текущих местных локальных переменных.

Мы можем использовать эти функции в любом месте кода, чтобы проверить, доступна ли переменная в этом месте или нет. Они встроены функции в Python.

Давайте посмотрим на несколько быстрых примеров этих функций.

global_var = "global"

def foo():
    local_var = "local"
    print('global variables inside foo(): ', globals())
    print('local variables inside foo(): ', locals())


print('global variables: ', globals())
print('local variables: ', locals())
foo()

Выход:

global variables:  {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x1006305f8>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': '/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/hello_world.py', '__cached__': None, 'global_var': 'global', 'foo': }
local variables:  {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x1006305f8>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': '/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/hello_world.py', '__cached__': None, 'global_var': 'global', 'foo': }
global variables inside foo():  {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x1006305f8>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': '/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/hello_world.py', '__cached__': None, 'global_var': 'global', 'foo': }
local variables inside foo():  {'local_var': 'local'}
Python Global Локальная переменная Область применения

Python global ключевое слово

Мы можем получить доступ к глобальной переменной внутри функции. Но мы не можем его изменить. Мы должны использовать глобальный Ключевое слово для изменения значения глобального переменного варианта внутри функции. Давайте понять это поведение простым примером.

name = "Python"

def foo():
    print(name)

foo()
print(name)

# Output
# Python
# Python

Давайте посмотрим, что произойдет, когда мы стараемся изменять глобальное значение переменной внутри функции.

>>> name = "Python"
>>> def foo():
...     print(name)
...     name = "Java"
... 
>>> 
>>> foo()
Traceback (most recent call last):
  File "", line 1, in 
  File "", line 2, in foo
UnboundLocalError: local variable 'name' referenced before assignment
>>> 
>>> print(name)
Python
>>>

Причина проста. Когда мы используем оператор присваивания для изменения значения «name», он начинает обрабатывать как локальную переменную. Поэтому доступ к нему внутри функции печати () бросается, потому что в этой точке она не определена.

Давайте использовать глобальное ключевое слово для изменения значения глобального переменной.

>>> name = "Python"
>>> 
>>> def foo():
...     global name
...     print(name)
...     name = "Java"
... 
>>> print(name)
Python
>>> foo()
Python
>>> print(name)
Java
>>>

Python nonlocal ключевое слово

Нелокальное ключевое слово используется для доступа к переменным, определенным за пределами объема блока. Это всегда используется в вложенных функциях для доступа переменных, определенных снаружи. Переменные всегда ищеты в ближайшем приложении, исключая глобал.

def outer_function():
    scope = "local"

    def inner_function():
        nonlocal scope
        scope = "nonlocal"
        print(scope)

    inner_function()
    print(scope)

Заключение

Переменные Python используются в каждой программе. Это тип идентификатора. Мы узнали, как определить переменную, правила, связанные с ней, и как получить доступ и удалять их. Мы также узнали об объеме переменных – глобальные и местные.

Читайте ещё по теме: