Python Language Tutoriel
Démarrer avec le langage Python

Remarques

Versions

Commencer

Python est un langage de programmation de haut niveau largement utilisé pour la programmation à usage général, créé par Guido van Rossum et publié pour la première fois en 1991. Python intègre un système de type dynamique et une gestion automatique de la mémoire. programmation fonctionnelle et styles procéduraux. Il a une bibliothèque standard large et complète.

Deux versions principales de Python sont actuellement utilisées:

• Python 3.x est la version actuelle et est en cours de développement.
• Python 2.x est la version héritée et ne recevra que les mises à jour de sécurité jusqu'en 2020. Aucune nouvelle fonctionnalité ne sera implémentée. Notez que de nombreux projets utilisent encore Python 2, bien que la migration vers Python 3 devienne plus facile.

Vous pouvez télécharger et installer les deux versions de Python ici . Voir Python 3 vs Python 2 pour une comparaison entre eux. De plus, certaines tierces parties proposent des versions reconditionnées de Python qui ajoutent des bibliothèques couramment utilisées et d'autres fonctionnalités pour faciliter la configuration des cas d'utilisation courants, tels que les mathématiques, l'analyse de données ou l'utilisation scientifique. Voir la liste sur le site officiel .

Vérifiez si Python est installé

Pour confirmer que Python a été installé correctement, vous pouvez le vérifier en exécutant la commande suivante dans votre terminal favori (si vous utilisez le système d'exploitation Windows, vous devez ajouter le chemin de python à la variable d'environnement avant de l'utiliser dans l'invite de commande):

$ python --version

$ python --version
Python 3.6.0

$ python --version
Python 2.7.13

Si vous avez installé Python 3, mais que $ python --version affiche une version Python 2, Python 2 est également installé. C'est souvent le cas sur MacOS et de nombreuses distributions Linux. Utilisez plutôt $ python3 pour utiliser explicitement l'interpréteur Python 3.

Bonjour, World in Python en utilisant IDLE

IDLE est un éditeur simple pour Python, fourni avec Python.

Comment créer Hello, programme mondial dans IDLE

• Ouvrez IDLE sur votre système de choix.
  • Dans les anciennes versions de Windows, il se trouve dans All Programs du menu Windows.
  • Dans Windows 8+, recherchez IDLE ou recherchez-le dans les applications présentes sur votre système.
  • Sur les systèmes Unix (y compris Mac), vous pouvez l’ouvrir à partir du shell en tapant $ idle python_file.py .
• Il ouvrira un shell avec des options en haut.

Dans le shell, il y a un prompt de trois parenthèses à angle droit:

>>>

Maintenant, écrivez le code suivant dans l'invite:

>>> print("Hello, World")

Appuyez sur Entrée .

>>> print("Hello, World")
Hello, World

Fichier Python Hello World

Créez un nouveau fichier hello.py contenant la ligne suivante:

print('Hello, World')

from __future__ import print_function

print 'Hello, World'

Dans votre terminal, accédez au répertoire contenant le fichier hello.py .

Tapez python hello.py , puis appuyez sur la touche Entrée .

$ python hello.py
Hello, World

Vous devriez voir Hello, World imprimé sur la console.

Vous pouvez également remplacer hello.py par le chemin d'accès à votre fichier. Par exemple, si vous avez le fichier dans votre répertoire personnel et que votre utilisateur est "utilisateur" sous Linux, vous pouvez taper python /home/user/hello.py .

Lancer un shell Python interactif

En exécutant (exécutant) la commande python dans votre terminal, vous obtenez un shell Python interactif. Ceci est également connu sous le nom d' Interpréteur Python ou REPL (pour 'Read Evaluate Print Loop').

$ python
Python 2.7.12 (default, Jun 28 2016, 08:46:01) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print 'Hello, World'
Hello, World
>>>

Si vous souhaitez exécuter Python 3 à partir de votre terminal, exécutez la commande python3 .

$ python3
Python 3.6.0 (default, Jan 13 2017, 00:00:00) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print('Hello, World')
Hello, World
>>>

Vous pouvez également lancer l'invite interactive et charger le fichier avec python -i <file.py> .

En ligne de commande, exécutez:

$ python -i hello.py
"Hello World"
>>>

Il existe plusieurs façons de fermer le shell Python:

>>> exit()

ou

>>> quit()

Alternativement, CTRL + D va fermer le shell et vous remettre sur la ligne de commande de votre terminal.

Si vous souhaitez annuler une commande en cours de saisie et revenir à une invite de commande propre, tout en restant dans le shell Interpreter, utilisez CTRL + C.

Essayez un shell Python interactif en ligne .

Autres coquilles en ligne

Divers sites Web offrent un accès en ligne aux shells Python.

Les shells en ligne peuvent être utiles aux fins suivantes:

• Exécutez un petit extrait de code à partir d'une machine dépourvue d'installation python (smartphones, tablettes, etc.).
• Apprendre ou enseigner le Python de base.
• Résoudre des problèmes de juge en ligne.

Exemples:

Déni de responsabilité: les auteurs de la documentation ne sont affiliés à aucune des ressources énumérées ci-dessous.

• https://www.python.org/shell/ - Le shell en ligne Python hébergé par le site Web officiel de Python.
• https://ideone.com/ - Largement utilisé sur le Net pour illustrer le comportement des extraits de code.
• 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:

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

2. 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" 

3. 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?

Entrée utilisateur

Saisie interactive

Pour obtenir la contribution de l'utilisateur, utilisez la fonction input ( remarque : dans Python 2.x, la fonction s'appelle raw_input place, bien que Python 2.x ait sa propre version d' input complètement différente):

name = raw_input("What is your name? ")
# Out: What is your name? _

name = input("What is your name? ")
# Out: What is your name? _

Le reste de cet exemple utilisera la syntaxe Python 3.

La fonction prend un argument de chaîne, qui l'affiche sous la forme d'une invite et renvoie une chaîne. Le code ci-dessus fournit une invite, attendant que l'utilisateur saisisse.

name = input("What is your name? ")
# Out: What is your name?

Si l'utilisateur tape "Bob" et frappe, entrez, le name la variable sera assigné à la chaîne "Bob" :

name = input("What is your name? ")
# Out: What is your name? Bob
print(name)
# Out: Bob

Notez que l' input est toujours de type str , ce qui est important si vous souhaitez que l'utilisateur entre des nombres. Par conséquent, vous devez convertir le str avant d'essayer de l'utiliser comme un nombre:

x = input("Write a number:")
# Out: Write a number: 10
x / 2
# Out: TypeError: unsupported operand type(s) for /: 'str' and 'int'
float(x) / 2
# Out: 5.0

NB: Il est recommandé d'utiliser des blocs try / except pour intercepter des exceptions lors de l'utilisation d'entrées utilisateur . Par exemple, si votre code souhaite raw_input un raw_input en un int et que ce que l’écrit est impossible à graver, il déclenche une ValueError .

IDLE - Python GUI

IDLE est l'environnement intégré de développement et d'apprentissage de Python et constitue une alternative à la ligne de commande. Comme son nom l'indique, IDLE est très utile pour développer un nouveau code ou apprendre le python. Sous Windows, ceci est fourni avec l'interpréteur Python, mais dans d'autres systèmes d'exploitation, vous devrez peut-être l'installer via votre gestionnaire de paquets.

Les principaux objectifs de IDLE sont:

• Éditeur de texte multi-fenêtre avec mise en évidence de la syntaxe, auto-complétion et mise en retrait intelligente
• Shell Python avec coloration syntaxique
• Débogueur intégré avec étapes, points d'arrêt persistants et visibilité de la pile d'appels
• Indentation automatique (utile pour les débutants en apprentissage de l'indentation de Python)
• Sauvegardez le programme Python en tant que fichiers .py et exécutez-les et modifiez-les ultérieurement à l'aide d'IDLE.

Dans IDLE, appuyez sur F5 ou run Python Shell pour lancer un interpréteur. Utiliser IDLE peut être une meilleure expérience d'apprentissage pour les nouveaux utilisateurs car le code est interprété comme l'utilisateur écrit.

Notez qu'il existe de nombreuses alternatives, voir par exemple cette discussion ou cette liste .

Dépannage

• les fenêtres

  Si vous utilisez Windows, la commande par défaut est python . Si vous recevez une erreur "'python' is not recognized" , la cause la plus probable est que l'emplacement de Python ne se trouve pas dans la variable d'environnement PATH votre système. Vous pouvez y accéder en cliquant avec le bouton droit sur "Poste de travail" et en sélectionnant "Propriétés" ou en naviguant sur "Système" via "Panneau de configuration". Cliquez sur "Paramètres système avancés" puis sur "Variables d'environnement ...". Modifiez la variable PATH pour inclure le répertoire de votre installation Python, ainsi que le dossier Script (généralement C:\Python27;C:\Python27\Scripts ). Cela nécessite des privilèges administratifs et peut nécessiter un redémarrage.

  Lorsque vous utilisez plusieurs versions de Python sur le même python.exe , une solution possible consiste à renommer l'un des fichiers python.exe . Par exemple, en nommant une version python27.exe , python27 deviendrait la commande Python pour cette version.

  Vous pouvez également utiliser Python Launcher pour Windows, disponible via le programme d'installation et fourni par défaut. Il vous permet de sélectionner la version de Python à exécuter en utilisant py -[xy] au lieu de python[xy] . Vous pouvez utiliser la dernière version de Python 2 en exécutant des scripts avec py -2 et la dernière version de Python 3 en exécutant des scripts avec py -3 .

• Debian / Ubuntu / MacOS

  Cette section suppose que l'emplacement de l'exécutable python a été ajouté à la variable d'environnement PATH .

  Si vous êtes sur Debian / Ubuntu / MacOS, ouvrez le terminal et tapez python pour Python 2.x ou python3 pour Python 3.x.

  Tapez le which python pour voir quel interpréteur Python sera utilisé.

• Arch Linux

  Python par défaut sur Arch Linux (et ses descendants) est Python 3, utilisez donc python ou python3 pour Python 3.x et python2 pour Python 2.x.

• D'autres systèmes

  Python 3 est parfois lié à python au lieu de python3 . Pour utiliser Python 2 sur ces systèmes sur lesquels il est installé, vous pouvez utiliser python2 .

Types de données

Types intégrés

Booléens

bool : Une valeur booléenne de True ou False . Les opérations logiques comme and or not peuvent not être effectuées sur des booléens.

x or y    # if x is False then y otherwise x 
x and y   # if x is False then x otherwise y
not x     # if x is True then False, otherwise True

Dans Python 2.x et dans Python 3.x, un booléen est aussi un int . Le type bool est une sous-classe du type int et True et False sont ses seules instances:

issubclass(bool, int) # True

isinstance(True, bool) # True
isinstance(False, bool) # True

Si des valeurs booléennes sont utilisées dans les opérations arithmétiques, leurs valeurs entières ( 1 et 0 pour True et False ) seront utilisées pour renvoyer un résultat entier:

True + False == 1 # 1 + 0 == 1
True * True  == 1 # 1 * 1 == 1

Nombres

• int : nombre entier

  a = 2
  b = 100
  c = 123456789
  d = 38563846326424324
  

  Les entiers en Python sont de tailles arbitraires.

  Remarque: dans les anciennes versions de Python, un type long était disponible, distinct de int . Les deux ont été unifiés.

• float : nombre à virgule flottante; la précision dépend de l'implémentation et de l'architecture du système, pour CPython, le type de données float correspond à un double C.

  a = 2.0
  b = 100.e0
  c = 123456789.e1
  

• complex : nombres complexes

  a = 2 + 1j
  b = 100 + 10j
  

Les opérateurs < , <= , > et >= TypeError une exception TypeError quand un opérande est un nombre complexe.

Cordes

Séquences et collections

Python différencie les séquences ordonnées et les collections non ordonnées (telles que set et dict ).

• les chaînes ( str , bytes , unicode ) sont des séquences

• reversed : ordre inverse de str avec fonction reversed

  a = reversed('hello')
  

• tuple : Collection ordonnée de n valeurs de tout type ( n >= 0 ).

  a = (1, 2, 3)
  b = ('a', 1, 'python', (1, 2))
  b[2] = 'something else' # returns a TypeError
  

  Supporte l'indexation immuable; hashable si tous ses membres sont lavables

• list : Une collection ordonnée de n valeurs ( n >= 0 )

  a = [1, 2, 3]
  b = ['a', 1, 'python', (1, 2), [1, 2]]
  b[2] = 'something else' # allowed
  

  Non lavable; mutable.

• set : Une collection non ordonnée de valeurs uniques. Les articles doivent être lavables .

  a = {1, 2, 'a'}
  

• dict : Une collection non ordonnée de paires clé-valeur uniques; les clés doivent être lavables .

  a = {1: 'one',
       2: 'two'}
  
  b = {'a': [1, 2, 3],
       'b': 'a string'}
  

Un objet est hashrable s'il a une valeur de hachage qui ne change jamais au cours de sa vie (il a besoin d'une __hash__() ) et peut être comparé à d'autres objets (il nécessite une __eq__() ). Les objets lavables qui comparent l'égalité doivent avoir la même valeur de hachage.

Constantes intégrées

En conjonction avec les types de données intégrés, il existe un petit nombre de constantes intégrées dans l'espace de noms intégré:

• True : La valeur réelle du type intégré bool
• False : La valeur false du type intégré bool
• None : objet singleton utilisé pour signaler qu'une valeur est absente.
• Ellipsis ou ... : utilisé dans Python3 + de base n'importe où et utilisation limitée dans Python2.7 + dans le cadre de la notation de tableau. numpy et les paquets associés l'utilisent comme référence "include everything" dans les tableaux.
• NotImplemented : un singleton utilisé pour indiquer à Python qu'une méthode spéciale ne prend pas en charge les arguments spécifiques, et Python essaiera des alternatives si elles sont disponibles.

a = None # No value will be assigned. Any valid datatype can be assigned later

Test du type de variables

En python, nous pouvons vérifier le type de données d'un objet en utilisant le type fonction intégré.

a = '123'
print(type(a))
# Out: <class 'str'>
b = 123
print(type(b))
# Out: <class 'int'>

Dans les instructions conditionnelles, il est possible de tester le type de données avec isinstance . Cependant, il n'est généralement pas recommandé de compter sur le type de la variable.

i = 7
if isinstance(i, int):
    i += 1
elif isinstance(i, str):
    i = int(i)
    i += 1

Pour plus d'informations sur les différences entre type() et isinstance() lisez: Différences entre isinstance et type dans Python

Pour tester si quelque chose est de NoneType :

x = None
if x is None:
    print('Not a surprise, I just defined x as None.')

Conversion entre types de données

Vous pouvez effectuer une conversion de type de données explicite.

Par exemple, '123' est de type str et peut être converti en entier en utilisant la fonction int .

a = '123'
b = int(a)

La conversion à partir d'une chaîne de caractères telle que «123.456» peut être effectuée à l'aide de la fonction float .

a = '123.456'
b = float(a)
c = int(a)    # ValueError: invalid literal for int() with base 10: '123.456'
d = int(b)    # 123

Vous pouvez également convertir des types de séquence ou de collection

a = 'hello'
list(a)  # ['h', 'e', 'l', 'l', 'o']
set(a)   # {'o', 'e', 'l', 'h'}
tuple(a) # ('h', 'e', 'l', 'l', 'o')

Type de chaîne explicite à la définition des littéraux

Avec des étiquettes d'une lettre juste devant les guillemets, vous pouvez indiquer le type de chaîne que vous souhaitez définir.

• b'foo bar' : bytes résultats dans Python 3, str dans Python 2
• u'foo bar' : résultats str dans Python 3, unicode dans Python 2
• 'foo bar' : résultats str
• r'foo bar' : résultat dit chaîne brute, où échapper des caractères spéciaux n'est pas nécessaire, tout est pris textuellement à mesure que vous tapez

normal  = 'foo\nbar'   # foo
                       # bar
escaped = 'foo\\nbar'  # foo\nbar   
raw     = r'foo\nbar'  # foo\nbar

Types de données mutables et immuables

Un objet est appelé mutable s'il peut être modifié. Par exemple, lorsque vous transmettez une liste à une fonction, la liste peut être modifiée:

def f(m):
    m.append(3)  # adds a number to the list. This is a mutation.

x = [1, 2]
f(x)
x == [1, 2]  # False now, since an item was added to the list

Un objet est appelé immuable s'il ne peut être modifié d'aucune façon. Par exemple, les entiers sont immuables, car il est impossible de les modifier:

def bar():
    x = (1, 2)
    g(x)
    x == (1, 2)  # Will always be True, since no function can change the object (1, 2)

Notez que les variables elles-mêmes sont mutables, nous pouvons donc réaffecter la variable x , mais cela ne change pas l’objet que x avait précédemment indiqué. Il ne fait x pointer vers un nouvel objet.

Les types de données dont les instances sont modifiables sont appelés types de données mutables , de même pour les objets et les types de données immuables.

Exemples de types de données immuables:

• int , long , float , complex
• str
• bytes
• tuple
• frozenset

Exemples de types de données mutables:

• bytearray
• list
• set
• dict

Modules et fonctions intégrés

Un module est un fichier contenant des définitions et des instructions Python. La fonction est un morceau de code qui exécute une logique.

>>> pow(2,3)    #8

Pour vérifier la fonction intégrée dans python, nous pouvons utiliser dir(). Si elle est appelée sans argument, retournez les noms dans la portée actuelle. Sinon, retournez une liste alphabétique des noms comprenant (certains) l’attribut de l’objet donné, et des attributs accessibles à partir de celui-ci.

>>> dir(__builtins__)
[
    'ArithmeticError', 
    'AssertionError', 
    'AttributeError', 
    'BaseException', 
    'BufferError', 
    'BytesWarning', 
    'DeprecationWarning', 
    'EOFError', 
    'Ellipsis', 
    'EnvironmentError', 
    'Exception', 
    'False', 
    'FloatingPointError', 
    'FutureWarning', 
    'GeneratorExit', 
    'IOError', 
    'ImportError', 
    'ImportWarning', 
    'IndentationError', 
    'IndexError', 
    'KeyError', 
    'KeyboardInterrupt', 
    'LookupError', 
    'MemoryError', 
    'NameError', 
    'None', 
    'NotImplemented', 
    'NotImplementedError', 
    'OSError', 
    'OverflowError', 
    'PendingDeprecationWarning', 
    'ReferenceError', 
    'RuntimeError', 
    'RuntimeWarning', 
    'StandardError', 
    'StopIteration', 
    'SyntaxError', 
    'SyntaxWarning', 
    'SystemError', 
    'SystemExit', 
    'TabError', 
    'True', 
    'TypeError', 
    'UnboundLocalError', 
    'UnicodeDecodeError', 
    'UnicodeEncodeError', 
    'UnicodeError', 
    'UnicodeTranslateError', 
    'UnicodeWarning', 
    'UserWarning', 
    'ValueError', 
    'Warning', 
    'ZeroDivisionError', 
    '__debug__', 
    '__doc__', 
    '__import__', 
    '__name__', 
    '__package__', 
    'abs', 
    'all', 
    'any', 
    'apply', 
    'basestring', 
    'bin', 
    'bool', 
    'buffer', 
    'bytearray', 
    'bytes', 
    'callable', 
    'chr', 
    'classmethod', 
    'cmp', 
    'coerce', 
    'compile', 
    'complex', 
    'copyright', 
    'credits', 
    'delattr', 
    'dict', 
    'dir', 
    'divmod', 
    'enumerate', 
    'eval', 
    'execfile', 
    'exit', 
    'file', 
    'filter', 
    'float', 
    'format', 
    'frozenset', 
    'getattr', 
    'globals', 
    'hasattr', 
    'hash', 
    'help', 
    'hex', 
    'id', 
    'input', 
    'int', 
    'intern', 
    'isinstance', 
    'issubclass', 
    'iter', 
    'len', 
    'license', 
    'list', 
    'locals', 
    'long', 
    'map', 
    'max', 
    'memoryview', 
    'min', 
    'next', 
    'object', 
    'oct', 
    'open', 
    'ord', 
    'pow', 
    'print', 
    'property', 
    'quit', 
    'range', 
    'raw_input', 
    'reduce', 
    'reload', 
    'repr', 
    'reversed', 
    'round', 
    'set', 
    'setattr', 
    'slice', 
    'sorted', 
    'staticmethod', 
    'str', 
    'sum', 
    'super', 
    'tuple', 
    'type', 
    'unichr', 
    'unicode', 
    'vars', 
    'xrange', 
    'zip'
]

Pour connaître la fonctionnalité de toute fonction, nous pouvons utiliser l' help fonction intégrée.

>>> help(max)
Help on built-in function max in module __builtin__:
max(...)
    max(iterable[, key=func]) -> value
    max(a, b, c, ...[, key=func]) -> value
    With a single iterable argument, return its largest item.
    With two or more arguments, return the largest argument.

Les modules intégrés contiennent des fonctionnalités supplémentaires. Par exemple, pour obtenir la racine carrée d'un nombre, nous devons inclure un module math .

>>> import math
>>> math.sqrt(16) # 4.0

Pour connaître toutes les fonctions d'un module, nous pouvons affecter la liste des fonctions à une variable, puis imprimer la variable.

>>> import math
>>> dir(math)

   ['__doc__', '__name__', '__package__', 'acos', 'acosh', 
   'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 
   'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 
   'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 
   'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 
   'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 
   'tan', 'tanh', 'trunc']

il semble que __doc__ soit utile pour fournir de la documentation dans, disons, des fonctions

>>> math.__doc__
'This module is always available.  It provides access to the\nmathematical
 functions defined by the C standard.'

Outre les fonctions, la documentation peut également être fournie sous forme de modules. Donc, si vous avez un fichier nommé helloWorld.py comme ceci:

"""This is the module docstring."""

def sayHello():
    """This is the function docstring."""
    return 'Hello World'

Vous pouvez accéder à ses docstrings comme ceci:

>>> import helloWorld
>>> helloWorld.__doc__
'This is the module docstring.'
>>> helloWorld.sayHello.__doc__
'This is the function docstring.'

• Pour tout type défini par l'utilisateur, ses attributs, ses attributs de classe et, de manière récursive, les attributs des classes de base de sa classe peuvent être récupérés à l'aide de dir ().

>>> class MyClassObject(object):
...     pass
... 
>>> dir(MyClassObject)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']

Tout type de données peut être simplement converti en chaîne en utilisant une fonction intégrée appelée str . Cette fonction est appelée par défaut lorsqu'un type de données est transmis à l' print

>>> str(123)    # "123"

Indentation de bloc

Python utilise l'indentation pour définir les constructions de contrôle et de boucle. Cela contribue à la lisibilité de Python, cependant, le programmeur doit faire très attention à l'utilisation des espaces. Ainsi, une erreur d’équilibrage de l’éditeur peut entraîner un comportement inattendu du code.

Python utilise le symbole de deux points ( : ) et en retrait pour montrer où des blocs de code début et la fin (Si vous venez d' une autre langue, ne pas confondre avec étant en quelque sorte lié à l' opérateur ternaire ). En d'autres termes, les blocs en Python, tels que les fonctions, les boucles, les clauses if et les autres constructions, n'ont aucun identificateur de fin. Tous les blocs commencent par deux points et contiennent ensuite les lignes en retrait.

Par exemple:

def my_function():    # This is a function definition. Note the colon (:)
    a = 2             # This line belongs to the function because it's indented
    return a          # This line also belongs to the same function
print(my_function())  # This line is OUTSIDE the function block

ou

if a > b:             # If block starts here
    print(a)          # This is part of the if block
else:                 # else must be at the same level as if
    print(b)          # This line is part of the else block

Les blocs qui contiennent exactement une instruction sur une seule ligne peuvent être placés sur la même ligne, bien que cette forme ne soit généralement pas considérée comme un bon style:

if a > b: print(a)
else: print(b)  

Essayer de le faire avec plus d’une seule déclaration ne fonctionnera pas :

if x > y: y = x
    print(y) # IndentationError: unexpected indent

if x > y: while y != z: y -= 1  # SyntaxError: invalid syntax

Un bloc vide provoque une IndentationError d' IndentationError . Utilisez pass (une commande qui ne fait rien) lorsque vous avez un bloc sans contenu:

def will_be_implemented_later():
    pass

Espaces vs. Onglets

En bref: utilisez toujours 4 espaces pour l'indentation.

L'utilisation exclusive des onglets est possible, mais PEP 8 , le guide de style pour le code Python, indique que les espaces sont préférés.

De nombreux éditeurs ont une configuration "tabs to spaces". Lors de la configuration de l'éditeur, il convient de différencier le caractère de tabulation ('\ t') et la touche Tab .

• Le caractère de tabulation doit être configuré pour afficher 8 espaces, correspondant à la sémantique du langage - au moins dans les cas où une indentation mixte (accidentelle) est possible. Les éditeurs peuvent également convertir automatiquement le caractère de tabulation en espaces.
• Cependant, il peut être utile de configurer l'éditeur de sorte que le fait d'appuyer sur la touche de tabulation insère 4 espaces, au lieu d'insérer un caractère de tabulation.

Le code source Python écrit avec un mélange de tabulations et d'espaces, ou avec un nombre d'espaces d'indentation non standard peut être rendu conforme à pep8 en utilisant autopep8 . (Une alternative moins puissante est fournie avec la plupart des installations Python: reindent.py )

Types de collection

Il existe un certain nombre de types de collection en Python. Bien que les types tels que int et str contiennent une seule valeur, les types de collection contiennent plusieurs valeurs.

Des listes

Le type de list est probablement le type de collection le plus utilisé en Python. Malgré son nom, une liste ressemble plus à un tableau dans d'autres langues, principalement du JavaScript. En Python, une liste est simplement une collection ordonnée de valeurs Python valides. Une liste peut être créée en entourant les valeurs, séparées par des virgules, entre crochets:

int_list = [1, 2, 3]
string_list = ['abc', 'defghi']

Une liste peut être vide:

empty_list = []

Les éléments d'une liste ne sont pas limités à un seul type de données, ce qui est logique étant donné que Python est un langage dynamique:

mixed_list = [1, 'abc', True, 2.34, None]

Une liste peut contenir une autre liste comme élément:

nested_list = [['a', 'b', 'c'], [1, 2, 3]]

Les éléments d'une liste sont accessibles via un index ou une représentation numérique de leur position. Les listes de Python sont indexées sur zéro, ce qui signifie que le premier élément de la liste est à l'index 0, le deuxième élément à l'index 1 et ainsi de suite:

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
print(names[0]) # Alice
print(names[2]) # Craig

Les indices peuvent également être négatifs, ce qui signifie compter à partir de la fin de la liste ( -1 étant l'indice du dernier élément). Donc, en utilisant la liste de l'exemple ci-dessus:

print(names[-1]) # Eric
print(names[-4]) # Bob

Les listes sont modifiables, vous pouvez donc modifier les valeurs d'une liste:

names[0] = 'Ann'
print(names)
# Outputs ['Ann', 'Bob', 'Craig', 'Diana', 'Eric']

En outre, il est possible d'ajouter et / ou de supprimer des éléments d'une liste:

Ajouter un objet à la fin de la liste avec L.append(object) , renvoie None .

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
names.append("Sia")
print(names) 
# Outputs ['Alice', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

Ajouter un nouvel élément à répertorier à un index spécifique. L.insert(index, object)

names.insert(1, "Nikki")
print(names)
# Outputs ['Alice', 'Nikki', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

Supprimer la première occurrence d'une valeur avec L.remove(value) , renvoie None

names.remove("Bob")
print(names) # Outputs ['Alice', 'Nikki', 'Craig', 'Diana', 'Eric', 'Sia']

Récupère l'index dans la liste du premier élément dont la valeur est x. Il affichera une erreur s'il n'y en a pas.

name.index("Alice")
0

Compter la longueur de la liste

len(names)
6

compter l'occurrence de n'importe quel élément de la liste

a = [1, 1, 1, 2, 3, 4]
a.count(1)
3

Inverser la liste

a.reverse()
[4, 3, 2, 1, 1, 1]
# or
a[::-1]
[4, 3, 2, 1, 1, 1]

Supprimer et renvoyer l'élément à l'index (par défaut au dernier élément) avec L.pop([index]) , renvoie l'élément

names.pop() # Outputs 'Sia'

Vous pouvez parcourir les éléments de la liste comme ci-dessous:

for element in my_list:
    print (element)

Tuples

Un tuple est similaire à une liste sauf qu'il est de longueur fixe et immuable. Ainsi, les valeurs du tuple ne peuvent pas être modifiées ni les valeurs ajoutées ou supprimées du tuple. Les tuples sont couramment utilisés pour les petites collections de valeurs qui n'auront pas besoin d'être modifiées, telles qu'une adresse IP et un port. Les tuples sont représentés par des parenthèses au lieu de crochets:

ip_address = ('10.20.30.40', 8080)

Les mêmes règles d'indexation pour les listes s'appliquent également aux tuples. Les tuples peuvent également être imbriqués et les valeurs peuvent être tout Python valide valide.

Un tuple avec un seul membre doit être défini (notez la virgule) de cette façon:

one_member_tuple = ('Only member',)

ou

one_member_tuple = 'Only member',   # No brackets

ou simplement en utilisant la syntaxe tuple

one_member_tuple = tuple(['Only member'])

Dictionnaires

Un dictionary en Python est une collection de paires clé-valeur. Le dictionnaire est entouré d'accolades. Chaque paire est séparée par une virgule et la clé et la valeur sont séparées par deux points. Voici un exemple:

state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}

Pour obtenir une valeur, référez-vous à sa clé:

ca_capital = state_capitals['California']

Vous pouvez également obtenir toutes les clés dans un dictionnaire, puis les parcourir:

for k in state_capitals.keys():
    print('{} is the capital of {}'.format(state_capitals[k], k))

Les dictionnaires ressemblent fortement à la syntaxe JSON. Le module json natif de la bibliothèque standard Python peut être utilisé pour convertir entre JSON et les dictionnaires.

ensemble

Un set est une collection d'éléments sans répétitions et sans ordre d'insertion, mais triés. Ils sont utilisés dans des situations où il est important que certaines choses soient regroupées et non dans quel ordre. Pour les grands groupes de données, il est beaucoup plus rapide de vérifier si un élément se trouve dans un set ou de faire la même chose pour une list .

La définition d'un set est très similaire à la définition d'un dictionary :

first_names = {'Adam', 'Beth', 'Charlie'}

Ou vous pouvez créer un set utilisant une list existante:

my_list = [1,2,3]
my_set = set(my_list)

Vérifier l'appartenance à l' set utilisant in :

if name in first_names:
    print(name)

Vous pouvez effectuer une itération sur un set exactement comme une liste, mais rappelez-vous que les valeurs seront dans un ordre arbitraire défini par la mise en œuvre.

par défaut

Un defaultdict est un dictionnaire avec une valeur par défaut pour les clés, de sorte que les clés pour lesquelles aucune valeur n'a été explicitement définie sont accessibles sans erreur. defaultdict est particulièrement utile lorsque les valeurs du dictionnaire sont des collections (listes, dicts, etc.) dans le sens où il n'est pas nécessaire de l'initialiser chaque fois qu'une nouvelle clé est utilisée.

Un defaultdict ne defaultdict jamais une erreur de clé. Toute clé inexistante renvoie la valeur par défaut.

Par exemple, considérez le dictionnaire suivant

>>> state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}

Si nous essayons d'accéder à une clé inexistante, python nous renvoie une erreur comme suit

>>> state_capitals['Alabama']
Traceback (most recent call last):

  File "<ipython-input-61-236329695e6f>", line 1, in <module>
    state_capitals['Alabama']

KeyError: 'Alabama'

Essayons avec un defaultdict par defaultdict . On peut le trouver dans le module des collections.

>>> from collections import defaultdict
>>> state_capitals = defaultdict(lambda: 'Boston')

Ce que nous avons fait ici est de définir une valeur par défaut ( Boston ) dans le cas où la clé de don n'existe pas. Maintenant, remplissez le dict comme avant:

>>> state_capitals['Arkansas'] = 'Little Rock'
>>> state_capitals['California'] = 'Sacramento'
>>> state_capitals['Colorado'] = 'Denver'
>>> state_capitals['Georgia'] = 'Atlanta'

Si nous essayons d'accéder au dict avec une clé inexistante, python nous renverra la valeur par défaut, à savoir Boston

>>> state_capitals['Alabama']
'Boston'

et renvoie les valeurs créées pour la clé existante, tout comme un dictionary normal

>>> state_capitals['Arkansas']
'Little Rock'

Utilitaire d'aide

Python a plusieurs fonctions intégrées dans l'interpréteur. Si vous souhaitez obtenir des informations sur les mots-clés, les fonctions intégrées, les modules ou les sujets, ouvrez une console Python et entrez:

>>> help()

Vous recevrez des informations en entrant directement les mots-clés:

>>> help(help)

ou dans l'utilitaire:

help> help

qui affichera une explication:

Help on _Helper in module _sitebuiltins object:

class _Helper(builtins.object)
 |  Define the builtin 'help'.
 |  
 |  This is a wrapper around pydoc.help that provides a helpful message
 |  when 'help' is typed at the Python interactive prompt.
 |  
 |  Calling help() at the Python prompt starts an interactive help session.
 |  Calling help(thing) prints help for the python object 'thing'.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args, **kwds)
 |  
 |  __repr__(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

Vous pouvez également demander des sous-classes de modules:

help(pymysql.connections)

Vous pouvez utiliser l'aide pour accéder aux docstrings des différents modules que vous avez importés, par exemple, essayez ce qui suit:

>>> help(math)

et vous aurez une erreur

>>> import math
>>> help(math)

Et maintenant, vous obtiendrez une liste des méthodes disponibles dans le module, mais seulement après que vous l'ayez importé.

Fermez l'aide avec quit

Créer un module

Un module est un fichier importable contenant des définitions et des instructions.

Un module peut être créé en créant un fichier .py .

# hello.py
def say_hello():
    print("Hello!")

Les fonctions d'un module peuvent être utilisées en important le module.

Pour les modules que vous avez créés, ils devront être dans le même répertoire que le fichier dans lequel vous les importez. (Cependant, vous pouvez également les placer dans le répertoire Python lib avec les modules pré-inclus, mais vous devriez les éviter si possible.)

$ python
>>> import hello
>>> hello.say_hello()
=> "Hello!"

Les modules peuvent être importés par d'autres modules.

# greet.py
import hello
hello.say_hello()

Des fonctions spécifiques d'un module peuvent être importées.

# greet.py
from hello import say_hello
say_hello()

Les modules peuvent être aliasés.

# greet.py
import hello as ai
ai.say_hello()

Un module peut être un script exécutable autonome.

# run_hello.py
if __name__ == '__main__':
    from hello import say_hello
    say_hello()

Exécuter!

$ python run_hello.py
=> "Hello!"

Si le module se trouve dans un répertoire et doit être détecté par python, le répertoire doit contenir un fichier nommé __init__.py .

Fonction de chaîne - str () et repr ()

Deux fonctions peuvent être utilisées pour obtenir une représentation lisible d'un objet.

repr(x) appelle x.__repr__() : une représentation de x . eval convertira généralement le résultat de cette fonction en objet d'origine.

str(x) appelle x.__str__() : une chaîne lisible par l'homme qui décrit l'objet. Cela peut éluder certains détails techniques.

repr ()

Pour de nombreux types, cette fonction tente de renvoyer une chaîne qui donnerait un objet ayant la même valeur lorsqu'il est transmis à eval() . Sinon, la représentation est une chaîne entre crochets qui contient le nom du type de l'objet ainsi que des informations supplémentaires. Cela inclut souvent le nom et l'adresse de l'objet.

str ()

Pour les chaînes, cela renvoie la chaîne elle-même. La différence entre ceci et repr(object) est que str(object) ne tente pas toujours de renvoyer une chaîne acceptable pour eval() . Son objectif est plutôt de retourner une chaîne imprimable ou lisible par l'homme. Si aucun argument n'est donné, cela retourne la chaîne vide, '' .

Exemple 1:

s = """w'o"w"""
repr(s) # Output: '\'w\\\'o"w\''  
str(s)  # Output: 'w\'o"w'
eval(str(s)) == s  # Gives a SyntaxError 
eval(repr(s)) == s # Output: True

Exemple 2:

import datetime
today = datetime.datetime.now()
str(today)  # Output: '2016-09-15 06:58:46.915000'
repr(today) # Output: 'datetime.datetime(2016, 9, 15, 6, 58, 46, 915000)'

Lors de l'écriture d'une classe, vous pouvez remplacer ces méthodes pour faire ce que vous voulez:

class Represent(object):

    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return "Represent(x={},y=\"{}\")".format(self.x, self.y)

    def __str__(self):
        return "Representing x as {} and y as {}".format(self.x, self.y)

En utilisant la classe ci-dessus, nous pouvons voir les résultats:

r = Represent(1, "Hopper")
print(r)  # prints __str__
print(r.__repr__)  # prints __repr__: '<bound method Represent.__repr__ of Represent(x=1,y="Hopper")>'
rep = r.__repr__()  # sets the execution of __repr__ to a new variable
print(rep)  # prints 'Represent(x=1,y="Hopper")'
r2 = eval(rep) # evaluates rep
print(r2)  # prints __str__ from new object
print(r2 == r)  # prints 'False' because they are different objects

Installation de modules externes à l'aide de pip

pip est votre ami lorsque vous devez installer un paquet à partir de la pléthore de choix disponibles dans l'index du package python (PyPI). pip est déjà installé si vous utilisez Python 2> = 2.7.9 ou Python 3> = 3.4 téléchargé depuis python.org. Pour les ordinateurs exécutant Linux ou un autre * nix avec un gestionnaire de paquets natif, pip doit souvent être installé manuellement.

Sur les instances sur pip3 Python 2 et Python 3 sont installés, pip fait souvent référence à Python 2 et à pip3 à Python 3. L'utilisation de pip n'installe que des packages pour Python 2 et pip3 installe uniquement des packages pour Python 3.

Rechercher / installer un paquet

Rechercher un paquet est aussi simple que de taper

$ pip search <query>
# Searches for packages whose name or summary contains <query>

L'installation d'un paquet est aussi simple que de taper (dans un terminal / une invite de commande, pas dans l'interpréteur Python)

$ pip install [package_name]           # latest version of the package

$ pip install [package_name]==x.x.x    # specific version of the package

$ pip install '[package_name]>=x.x.x'  # minimum version of the package

où xxx est le numéro de version du package que vous souhaitez installer.

Lorsque votre serveur est derrière un proxy, vous pouvez installer le package en utilisant la commande ci-dessous:

$ pip --proxy http://<server address>:<port> install

Mise à niveau des packages installés

Lorsque de nouvelles versions de packages installés apparaissent, elles ne sont pas automatiquement installées sur votre système. Pour avoir un aperçu des paquets installés qui sont devenus obsolètes, exécutez:

$ pip list --outdated

Pour mettre à niveau un package spécifique

$ pip install [package_name] --upgrade

La mise à jour de tous les paquets obsolètes n'est pas une fonctionnalité standard de pip .

Mise à niveau pip

Vous pouvez mettre à niveau votre installation existante de pip en utilisant les commandes suivantes

• Sous Linux ou MacOS X:

  $ pip install -U pip
  

  Vous devrez peut-être utiliser sudo avec pip sur certains systèmes Linux

• Sous Windows:

  py -m pip install -U pip
  

  ou

  python -m pip install -U pip
  

Pour plus d'informations concernant pip, lisez ici .

Installation de Python 2.7.x et 3.x

Remarque : Les instructions suivantes sont écrites pour Python 2.7 (sauf indication contraire): les instructions pour Python 3.x sont similaires.

LES FENÊTRES

Tout d'abord, téléchargez la dernière version de Python 2.7 à partir du site Web officiel ( https://www.python.org/downloads/) . La version est fournie en tant que package MSI. Pour l'installer manuellement, double-cliquez simplement sur le fichier.

Par défaut, Python installe dans un répertoire:

 C:\Python27\

Attention: l'installation ne modifie pas automatiquement la variable d'environnement PATH.

En supposant que votre installation Python se trouve dans C: \ Python27, ajoutez ceci à votre PATH:

C:\Python27\;C:\Python27\Scripts\

Maintenant, pour vérifier si l'installation de Python est valide, écrivez dans cmd:

python --version

Python 2.x et 3.x côte à côte

Pour installer et utiliser Python 2.x et 3.x côte à côte sur une machine Windows:

1. Installez Python 2.x à l'aide du programme d'installation MSI.

   • Assurez-vous que Python est installé pour tous les utilisateurs.
   • Facultatif: ajoutez Python à PATH pour pouvoir PATH Python 2.x à partir de la ligne de commande en utilisant python .

2. Installez Python 3.x en utilisant son installateur respectif.

   • Encore une fois, assurez-vous que Python est installé pour tous les utilisateurs.
   • Facultatif: ajoutez Python à PATH pour pouvoir PATH Python 3.x à partir de la ligne de commande en utilisant python . Cela peut remplacer PATH paramètres PATH Python 2.x. Vérifiez donc votre PATH et assurez-vous qu'il est configuré selon vos préférences.
   • Assurez-vous d'installer le py launcher pour tous les utilisateurs.

Python 3 va installer le lanceur Python qui peut être utilisé pour lancer Python 2.x et Python 3.x de manière interchangeable depuis la ligne de commande:

P:\>py -3
Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 17:54:52) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

C:\>py -2
Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 20:42:59) [MSC v.1500 32 Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

Pour utiliser la version correspondante de pip pour une version Python spécifique, utilisez:

C:\>py -3 -m pip -V
pip 9.0.1 from C:\Python36\lib\site-packages (python 3.6)

C:\>py -2 -m pip -V
pip 9.0.1 from C:\Python27\lib\site-packages (python 2.7)

LINUX

Les dernières versions de CentOS, Fedora, Redhat Enterprise (RHEL) et Ubuntu sont livrées avec Python 2.7.

Pour installer Python 2.7 sur Linux manuellement, procédez comme suit dans le terminal:

wget --no-check-certificate https://www.python.org/ftp/python/2.7.X/Python-2.7.X.tgz
tar -xzf Python-2.7.X.tgz  
cd Python-2.7.X
./configure  
make  
sudo make install

Ajoutez également le chemin du nouveau python dans la variable d'environnement PATH. Si le nouveau python est dans /root/python-2.7.X alors lancez export PATH = $PATH:/root/python-2.7.X

Maintenant, pour vérifier si l'installation de Python est valide en écriture dans le terminal:

python --version

Ubuntu (De la source)

Si vous avez besoin de Python 3.6, vous pouvez l'installer à partir du source, comme indiqué ci-dessous (Ubuntu 16.10 et 17.04 ont une version 3.6 dans le référentiel universel). Les étapes ci-dessous doivent être suivies pour Ubuntu 16.04 et les versions inférieures:

sudo apt install build-essential checkinstall
sudo apt install libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev libgdbm-dev libc6-dev libbz2-dev
wget https://www.python.org/ftp/python/3.6.1/Python-3.6.1.tar.xz
tar xvf Python-3.6.1.tar.xz 
cd Python-3.6.1/
./configure --enable-optimizations
sudo make altinstall

macOS

En ce moment, macOS est installé avec Python 2.7.10, mais cette version est obsolète et légèrement modifiée par rapport au Python classique.

La version de Python fournie avec OS X est idéale pour l'apprentissage, mais elle n'est pas bonne pour le développement. La version livrée avec OS X peut être obsolète par rapport à la version officielle actuelle de Python, considérée comme la version de production stable. ( source )

Installez Homebrew :

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Installez Python 2.7:

brew install python

Pour Python 3.x, utilisez plutôt la commande brew install python3 .