Python Language Creando variables y asignando valores.


Ejemplo

Para crear una variable en Python, todo lo que necesita hacer es especificar el nombre de la variable y luego asignarle un valor.

<variable name> = <value>

Python usa = para asignar valores a las variables. No es necesario declarar una variable por adelantado (o asignarle un tipo de datos), al asignar un valor a una variable, se declara e inicializa la variable con ese valor. No hay forma de declarar una variable sin asignarle un valor inicial.

# 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

La asignación de variables funciona de izquierda a derecha. Así que lo siguiente te dará un error de sintaxis.

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

No puede utilizar palabras clave de python como un nombre de variable válido. Puedes ver la lista de palabras clave por:

import keyword
print(keyword.kwlist)

Reglas para nombrar variables:

  1. Los nombres de las variables deben comenzar con una letra o un guión bajo.
 x  = True   # valid
 _y = True   # valid

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

 $y = False #  starts with symbol 
 => SyntaxError: invalid syntax
  1. El resto de su nombre de variable puede consistir en letras, números y guiones bajos.
has_0_in_it = "Still Valid" 
  1. Los nombres son mayúsculas y minúsculas.
x = 9  
y = X*5   
=>NameError: name 'X' is not defined

Aunque no es necesario especificar un tipo de datos al declarar una variable en Python, mientras se asigna el área necesaria en la memoria para la variable, el intérprete de Python selecciona automáticamente el tipo incorporado más adecuado para ella:

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'>

Ahora que conoce los conceptos básicos de la asignación, dejemos de lado esta sutileza acerca de la asignación en python.

Cuando usa = para realizar una operación de asignación, lo que está a la izquierda de = es un nombre para el objeto a la derecha. Finalmente, lo que hace = es asignar la referencia del objeto a la derecha al nombre a la izquierda.

Es decir:

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

Entonces, de los muchos ejemplos de asignación anteriores, si seleccionamos pi = 3.14 , pi es un nombre (no el nombre, ya que un objeto puede tener varios nombres) para el objeto 3.14 . Si no entiende algo a continuación, vuelva a este punto y lea esto nuevamente. Además, puedes echarle un vistazo a esto para una mejor comprensión.


Puede asignar múltiples valores a múltiples variables en una línea. Tenga en cuenta que debe haber el mismo número de argumentos en los lados derecho e izquierdo del operador = :

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

El error en el último ejemplo puede obviarse asignando valores restantes a un número igual de variables arbitrarias. Esta variable ficticia puede tener cualquier nombre, pero es convencional usar el subrayado ( _ ) para asignar valores no deseados:

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

Tenga en cuenta que el número de _ y el número de valores restantes deben ser iguales. De lo contrario, se lanzan 'demasiados valores para descomprimir el error' como se indica arriba:

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)

También puede asignar un solo valor a varias variables simultáneamente.

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

Cuando se utiliza dicha asignación en cascada, es importante tener en cuenta que las tres variables a , b y c se refieren al mismo objeto en la memoria, un int objeto con el valor de 1. En otras palabras, a , b y c son tres nombres diferentes dado al mismo objeto int. Asignar un objeto diferente a uno de ellos después no cambia los otros, como se esperaba:

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.

Lo anterior también es válido para los tipos mutables (como list , dict , etc.), al igual que para los tipos inmutables (como int , string , tuple , etc.):

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]

Hasta ahora tan bueno. Las cosas son un poco diferentes cuando se trata de modificar el objeto (en contraste con asignar el nombre a un objeto diferente, como hicimos anteriormente) cuando la asignación en cascada se usa para tipos mutables. Echa un vistazo a continuación, y lo verás de primera mano:

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

Las listas anidadas también son válidas en python. Esto significa que una lista puede contener otra lista como un elemento.

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

Por último, las variables en Python no tienen que ser del mismo tipo de las que se definieron por primera vez; simplemente puede usar = para asignar un nuevo valor a una variable, incluso si ese valor es de un tipo diferente.

a = 2 
print(a)
# Output: 2

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

Si esto te molesta, piensa en el hecho de que lo que está a la izquierda de = es solo un nombre para un objeto. En primer lugar se llama a la int objeto con valor de 2 a , a continuación, cambia de opinión y decide dar el nombre a a una string objeto, que tiene un valor 'Valor nuevo'. Simple, ¿verdad?