https://repl.it/languages/python3 - Compilateur en ligne puissant et simple, IDE et interpréteur. Code, compiler et exécuter du code en Python.
•
https://www.tutorialspoint.com/execute_python_online.php - Shell UNIX complet et explorateur de projet convivial.
•
http://rextester.com/l/python3_online_compiler - IDE simple et facile à utiliser qui affiche le temps d'exécution
•
Exécuter des commandes sous forme de
chaîne
Python peut être passé du code arbitraire sous forme de chaîne dans le shell:
$ python -c 'print("Hello, World")' Hello, World
Cela peut être utile lors de la concaténation des résultats de scripts dans le shell.
Coquillages et au-delà
Gestion des packages - L'outil recommandé par PyPA pour installer les packages Python est PIP . Pour l'installer, sur la ligne de commande, exécutez pip install <the package name> . Par exemple, pip install numpy . (Remarque: sur Windows, vous devez ajouter pip à vos variables
d'environnement PATH. Pour éviter cela, utilisez python -m pip install <the package name> ) Shells - Jusqu'à présent, nous avons discuté de différentes manières d'exécuter du code en utilisant le shell interactif natif de Python. Les coquilles utilisent le pouvoir d'interprétation de Python pour expérimenter le code en temps réel. Les shells alternatifs incluent IDLE - une interface graphique pré-intégrée, IPython - connu pour étendre l'expérience interactive, etc. Programmes - Pour le stockage à long terme, vous pouvez enregistrer le contenu dans des
fichiers .py et les éditer / exécuter en tant que scripts ou programmes avec des outils externes tels que shell, IDE ( PyCharm ), ordinateurs portables Jupyter , etc. Cependant, les méthodes
présentées ici sont suffisantes pour commencer.
Python tutor vous permet de parcourir le code Python afin de visualiser le déroulement du programme et de vous aider à comprendre où votre programme a mal tourné.
PEP8 définit des directives pour le formatage du code Python. Le formatage du code est important pour que vous puissiez lire rapidement le code.
Création de variables et affectation de valeurs
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:
Les noms de variables doivent commencer par une lettre ou un trait de soulignement. 1.
x = True # valid _y = True # valid
9x = False # starts with numeral => SyntaxError: invalid syntax
$y = False # starts with symbol => SyntaxError: invalid syntax
Le reste de votre nom de variable peut être composé de lettres, de chiffres et de traits de soulignement.
2.
has_0_in_it = "Still Valid"
Les noms sont sensibles à la casse. 3.
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?