Python Language Création de variables et affectation de valeurs


Exemple

Pour créer une variable en Python, il vous suffit de spécifier le nom de la variable, puis de lui attribuer une valeur.

<variable name> = <value>

Python utilise = pour attribuer des valeurs aux variables. Il n'est pas nécessaire de déclarer une variable à l'avance (ou de lui attribuer un type de données), l'affectation d'une valeur à une variable elle-même déclare et initialise la variable avec cette valeur. Il n'y a aucun moyen de déclarer une variable sans lui attribuer une valeur initiale.

# 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

L'attribution des variables fonctionne de gauche à droite. Donc, ce qui suit vous donnera une erreur de syntaxe.

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

Vous ne pouvez pas utiliser les mots-clés de python comme nom de variable valide. Vous pouvez voir la liste des mots clés par:

import keyword
print(keyword.kwlist)

Règles de nommage des variables:

  1. Les noms de variables doivent commencer par une lettre ou un trait de soulignement.
 x  = True   # valid
 _y = True   # valid

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

 $y = False #  starts with symbol 
 => SyntaxError: invalid syntax
  1. Le reste de votre nom de variable peut être composé de lettres, de chiffres et de traits de soulignement.
has_0_in_it = "Still Valid" 
  1. Les noms sont sensibles à la casse.
x = 9  
y = X*5   
=>NameError: name 'X' is not defined

Même s'il n'est pas nécessaire de spécifier un type de données lors de la déclaration d'une variable en Python, tout en allouant la zone nécessaire en mémoire à la variable, l'interpréteur Python sélectionne automatiquement le type intégré le plus approprié:

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

Maintenant que vous connaissez les bases de l'assignation, voyons cette subtilité à propos de l'affectation en python.

Lorsque vous utilisez = pour effectuer une opération d'affectation, ce qui est à gauche de = est un nom pour l' objet à droite. Enfin, quel = fait est assigner la référence de l'objet sur le droit au nom de la gauche.

C'est:

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

Donc, à partir de nombreux exemples d'affectation ci-dessus, si nous choisissons pi = 3.14 , alors pi est un nom (pas le nom, car un objet peut avoir plusieurs noms) pour l'objet 3.14 . Si vous ne comprenez pas quelque chose ci-dessous, revenez à ce point et lisez-le à nouveau! En outre, vous pouvez jeter un oeil à ce pour une meilleure compréhension.


Vous pouvez affecter plusieurs valeurs à plusieurs variables sur une seule ligne. Notez qu'il doit y avoir le même nombre d'arguments sur les côtés droit et gauche de l'opérateur = :

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

L'erreur dans le dernier exemple peut être évitée en attribuant des valeurs restantes à un nombre égal de variables arbitraires. Cette variable factice peut avoir n'importe quel nom, mais il est habituel d'utiliser le trait de soulignement ( _ ) pour attribuer des valeurs indésirables:

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

Notez que le nombre de _ et le nombre de valeurs restantes doivent être égaux. Sinon, "trop ​​de valeurs pour décompresser l'erreur" sont renvoyées comme ci-dessus:

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)

Vous pouvez également affecter une valeur unique à plusieurs variables simultanément.

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

Lors de l'utilisation d'une telle assignation en cascade, il est important de noter que les trois variables a , b et c font référence au même objet en mémoire, un objet int ayant la valeur 1. En d'autres termes, a , b et c sont trois noms différents donné au même objet int. L'attribution d'un objet différent à l'un d'eux ne modifie pas les autres, comme prévu:

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.

Ce qui précède est également vrai pour les types mutables (tels que list , dict , etc.) comme pour les types immuables (comme 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]

Jusqu'ici tout va bien. Les choses sont un peu différentes en ce qui concerne la modification de l'objet (contrairement à l' attribution du nom à un objet différent, ce que nous avons fait précédemment) lorsque l'affectation en cascade est utilisée pour les types mutables. Jetez un oeil ci-dessous, et vous le verrez de première main:

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

Les listes imbriquées sont également valables en python. Cela signifie qu'une liste peut contenir une autre liste en tant qu'élément.

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

Enfin, les variables en Python ne doivent pas nécessairement rester du même type que celles définies pour la première fois - vous pouvez simplement utiliser = pour attribuer une nouvelle valeur à une variable, même si cette valeur est d'un type différent.

a = 2 
print(a)
# Output: 2

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

Si cela vous dérange, pensez au fait que ce qui est à gauche de = est juste un nom pour un objet. D'abord, vous appelez l'objet int avec la valeur 2 a , puis vous changez d'avis et décidez de donner le nom a à un objet string ayant la valeur 'Nouvelle valeur'. Simple, non?