Создание переменных и присвоение значений

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

 <variable name> = <value>

 

Python использует = для присваивания значений переменных. Нет необходимости заранее объявлять переменную (или назначать ей тип данных), присваивая значение самой переменной, объявляет и инициализирует переменную с этим значением. Нет способа объявить переменную без присвоения ей начального значения.

 # Integer
a = 2
print(a)
# Output: 2

# Integer    
b = 9223372036854775807
print(b)
# Output: 9223372036854775807

# Floating point
pi = 3.14
print(pi)
# Output: 3.14

# String
c = 'A'
print(c)
# Output: A

# String    
name = 'John Doe'
print(name)
# Output: John Doe

# Boolean    
q = True
print(q)
# Output: True

# Empty value or null data type
x = None
print(x)
# Output: None

 

Переменная присваивания работает слева направо. Таким образом, следующее даст вам синтаксическую ошибку.

 0 = x
=> Output: SyntaxError: can't assign to literal

 

Вы не можете использовать ключевые слова Python в качестве допустимого имени переменной. Вы можете увидеть список ключевых слов по:

 import keyword
print(keyword.kwlist)

 

Правила именования переменных:

  1. Имена переменных должны начинаться с буквы или подчеркивания.
  x  = True   # valid
 _y = True   # valid

 9x = False  # starts with numeral 
 => SyntaxError: invalid syntax   

 $y = False #  starts with symbol 
 => SyntaxError: invalid syntax

 
  1. Остальная часть имени вашей переменной может состоять из букв, цифр и символов подчеркивания.
 has_0_in_it = "Still Valid" 

 
  1. Имена чувствительны к регистру.
 x = 9  
y = X*5   
=>NameError: name 'X' is not defined


 

Несмотря на то, что нет необходимости указывать тип данных при объявлении переменной в Python, при выделении необходимой площади в памяти для переменной, интерпретатор Python автоматически выбирает наиболее подходящий встроенный тип для него:

 a = 2
print(type(a))
# Output: <type 'int'>

b = 9223372036854775807
print(type(b))
# Output: <type 'int'>

pi = 3.14
print(type(pi))
# Output: <type 'float'>

c = 'A'
print(type(c))
# Output: <type 'str'>

name = 'John Doe'
print(type(name))
# Output: <type 'str'>

q = True
print(type(q))
# Output: <type 'bool'>

x = None
print(type(x))
# Output: <type 'NoneType'>

 

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

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

То есть:

 a_name = an_object  # "a_name" is now a name for the reference to the object "an_object"

 

Так, из многих примеров присваивания выше, если мы выбираем pi = 3.14 , то pi этого имя (не имя, так как объект может иметь несколько имен) для объекта 3.14 . Если вы не понимаете что-то ниже, вернитесь к этому пункту и прочитайте это снова! Кроме того , вы посмотрите на может это для лучшего понимания.

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

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

a, b, c = 1, 2
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b, c = 1, 2
=> ValueError: need more than 2 values to unpack

a, b = 1, 2, 3
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b = 1, 2, 3
=> ValueError: too many values to unpack

 

Ошибка в последнем примере может быть устранена путем присвоения оставшихся значений равному количеству произвольных переменных. Эта фиктивная переменная может иметь любое имя, но оно принято использовать подчеркивание ( _ ) для назначения ненужных значений:

 a, b, _ = 1, 2, 3
print(a, b)
# Output: 1, 2

 

Обратите внимание, что число _ и количество оставшихся значений должны быть равны. В противном случае выдается «слишком много значений для распаковки ошибки», как указано выше:

 a, b, _ = 1,2,3,4
=>Traceback (most recent call last):
=>File "name.py", line N, in <module>
=>a, b, _ = 1,2,3,4
=>ValueError: too many values to unpack (expected 3)


 

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

 a = b = c = 1
print(a, b, c)
# Output: 1 1 1

 

При использовании такого назначения каскадный, важно отметить , что все три переменные , a b и c относятся к одному объекту в памяти, в int объект со значением , равным 1. Другими словами, , a b и c являются три разные имена дано тому же объекту int. Присвоение другого объекта одному из них впоследствии не меняет других, как и ожидалось:

 a = b = c = 1    # all three names a, b and c refer to same int object with value 1
print(a, b, c)
# Output: 1 1 1
b = 2            # b now refers to another int object, one with a value of 2
print(a, b, c)
# Output: 1 2 1  # so output is as expected.

 

Выше верно и для изменяемых типов (например , list , dict и т.д.) так же , как это верно для неизменных типов (например , int , string , tuple и т.д.):

 x = y = [7, 8, 9]   # x and y refer to the same list object just created, [7, 8, 9]
x = [13, 8, 9]      # x now refers to a different list object just created, [13, 8, 9]
print(y)            # y still refers to the list it was first assigned
# Output: [7, 8, 9]

 

Все идет нормально. Вещи немного отличаются , когда речь идет об изменении объекта (в отличии от присвоения имени к другому объекту, который мы делали выше) , когда назначение каскадного используются для изменяемых типов. Посмотрите ниже, и вы увидите это из первых рук:

 x = y = [7, 8, 9]     # x and y are two different names for the same list object just created, [7, 8, 9]
x[0] = 13             # we are updating the value of the list [7, 8, 9] through one of its names, x in this case
print(y)              # printing the value of the list using its other name
# Output: [13, 8, 9]  # hence, naturally the change is reflected

 

Вложенные списки также действительны в Python. Это означает, что список может содержать другой список в качестве элемента.

 x = [1, 2, [3, 4, 5], 6, 7] # this is nested list
print x[2]
# Output: [3, 4, 5]
print x[2][1]
# Output: 4

 

И, наконец, переменные в Python не должны оставаться один и тот же тип, который они впервые были определены - вы можете просто использовать = присвоить новое значение переменной, даже если это значение другого типа.

 a = 2 
print(a)
# Output: 2

a = "New value"
print(a)
# Output: New value

 

Если это беспокоит вас, подумайте о том , что то , что слева от = это просто имя для объекта. Во- первых вы вызываете int объект со значением 2 , то вы передумали и решили дать имя a a , к string объекту, имеющему значение «Нового значения». Просто, правда?