4.3 Les débuts avec le langage Python

Pluie préliminaire

Donc, vous voulez apprendre le langage de programmation Python mais vous ne pouvez pas trouver un tutoriel concis mais complet. Ce tutoriel tentera de vous apprendre Python en 10 minutes. Ce n'est probablement pas tellement un tutoriel car c'est un croisement entre un tutoriel et une feuille de triche, donc il vous montrera juste quelques concepts de base pour vous aider à démarrer. Évidemment, si vous voulez vraiment apprendre un langage, vous devez programmer dans ce langage pendant un certain temps. Je supposerai que vous êtes déjà familier avec la programmation et sauter la plupart des choses non spécifiques au langage. Les mots clés importants seront mis en évidence afin que vous puissiez les repérer facilement.

Nous allons nous concentrer sur Python 3, car c'est la version que vous devriez utiliser. Tous les exemples dans le livre sont en Python 3, et si quelqu'un vous conseille d'utiliser 2, ils ne sont pas vos amis.

Propriétés

Python est fortement typé (c'est-à-dire que les types sont appliqués), dynamiquement, implicitement typé (c'est-à-dire que vous n'avez pas à déclarer de variables), sensible aux cas (c'est-à-dire que var et VAR sont deux variables différentes) et orienté objet (c'est-à-dire que tout est un objet).

Obtenir de l'aide

L'aide en Python est toujours disponible directement dans l'interpréteur. Si vous voulez savoir comment un objet fonctionne, tout ce que vous avez à faire est d'appeler help(Docteur!, qui vous montre sa chaîne de documentation:

>>> help(5)
Help on int object:
(etc etc)

>>> dir(5)
['__abs__', '__add__', ...]

>>> abs.__doc__
'abs(number) -> number

Return the absolute value of the argument.

Syntaxe

Python n'a pas de caractères obligatoires de terminaison d'instruction et les blocs sont spécifiés par indentation. Indent pour commencer un bloc, dedent pour terminer un. Les instructions qui s'attendent à un niveau d'indentation se terminent par un colon (:). Les commentaires commencent par le signe de la livre (#) et sont en ligne unique, les chaînes de caractères à plusieurs lignes sont utilisées pour les commentaires à plusieurs lignes. Les valeurs sont attribuées (en fait, les objets sont liés à des noms) avec le signe d'égalité (=), et le test d'égalité est effectué à l'aide de deux signes d'égalité (==). Vous pouvez augmenter / diminuer les valeurs en utilisant les opérateurs += et -= respectivement par la quantité de droite. Cela fonctionne sur de nombreux types de données, chaînes comprises. Vous pouvez également utiliser plusieurs variables sur une ligne. Par exemple:

>>> myvar = 3
>>> myvar += 2
>>> myvar
5
>>> myvar -= 1
>>> myvar
4
"""This is a multiline comment.
The following lines concatenate the two strings."""
>>> mystring = "Hello"
>>> mystring += " world."
>>> print(mystring)
Hello world.
# This swaps the variables in one line(!).
# It doesn't violate strong typing because values aren't
# actually being assigned, but new objects are bound to
# the old names.
>>> myvar, mystring = mystring, myvar

Types de données

Les structures de données disponibles dans python sont des listes, des tuples et des dictionnaires. Les ensembles sont disponibles dans la bibliothèque des ensembles (mais sont intégrés dans Python 2.5 et ultérieurs). Les listes sont comme des tableaux unidimensionnels (mais vous pouvez également avoir des listes d'autres listes), les dictionnaires sont des tableaux associatifs (également appelés tables de hachage) et les tuples sont des tableaux unidimensionnels immuables (Python arrays peut être de n'importe quel type, de sorte que vous pouvez mélanger par exemple des entiers, des chaînes, etc. dans les listes / dictionnaires / tuples). L'index du premier élément dans tous les types d'array est 0.

>>> sample = [1, ["another", "list"], ("a", "tuple")]
>>> mylist = ["List item 1", 2, 3.14]
>>> mylist[0] = "List item 1 again" # We're changing the item.
>>> mylist[-1] = 3.21 # Here, we refer to the last item.
>>> mydict = {"Key 1": "Value 1", 2: 3, "pi": 3.14}
>>> mydict["pi"] = 3.15 # This is how you change dictionary values.
>>> mytuple = (1, 2, 3)
>>> myfunction = len
>>> print(myfunction(mylist))
3

L'indexation est inclusive-exclusive, donc spécifier [2:10] renverra les éléments [2] (le troisième élément, à cause de l'indexation 0) à [9] (le dixième élément), inclusive (8 éléments).

>>> mylist = ["List item 1", 2, 3.14]
>>> print(mylist[:])
['List item 1', 2, 3.1400000000000001]
>>> print(mylist[0:2])
['List item 1', 2]
>>> print(mylist[-3:-1])
['List item 1', 2]
>>> print(mylist[1:])
[2, 3.14]
# Adding a third parameter, "step" will have Python step in
# N item increments, rather than 1.
# E.g., this will return the first item, then go to the third and
# return that (so, items 0 and 2 in 0-indexing).
>>> print(mylist[::2])
['List item 1', 3.14]

Les cordes

Ses chaînes peuvent utiliser des guillemets simples ou doubles, et vous pouvez avoir des guillemets d'un type à l'intérieur d'une chaîne qui utilise l'autre type (c.-à-d.les cotations triple double (ou simple)(). Les chaînes Python sont toujours Unicode, mais il existe un autre type de chaîne qui est des octets purs. Ceux-ci sont appelés bystrings et sont représentés par le préfixe b, par exemple bHello \xce\xb1. Pour remplir une chaîne de valeurs, vous utilisez l'opérateur % (modulo) et une tuple. Chaque %s est remplacé par un élément de la tuple, de gauche à droite, et vous pouvez également utiliser des substitutions de dictionnaire, comme ceci:

>>> print("Name: %s\
Number: %s\
String: %s" % (myclass.name, 3, 3 * "-"))
Name: Stavros
Number: 3
String: ---

strString = """This is
a multiline
string."""

# WARNING: Watch out for the trailing s in "%(key)s".
>>> print("This %(verb)s a %(noun)s." % {"noun": "test", "verb": "is"})
This is a test.

>>> name = "Stavros"
>>> "Hello, {}!".format(name)
Hello, Stavros!
>>> print(f"Hello, {name}!")
Hello, Stavros!

Déclarations de contrôle des écoulements

Les instructions de contrôle de flux sont if, for, et while. Il n'y a pas de switch; à la place, utilisez if. Utilisez for pour énumérer à travers les membres d'une liste. Pour obtenir une séquence de nombres que vous pouvez itérer, utilisez range() . La syntaxe de ces instructions est donc:

rangelist = list(range(10))
>>> print(rangelist)
range(0, 10)
>>> print(list(rangelist))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

for number in rangelist:
    # Check if number is one of
    # the numbers in the tuple.
    if number in (3, 4, 7, 9):
        # "Break" terminates a for without
        # executing the "else" clause.
        break
    else:
        # "Continue" starts the next iteration
        # of the loop. It's rather useless here,
        # as it's the last statement of the loop.
        continue
else:
    # The "else" clause is optional and is
    # executed only if the loop didn't "break".
    pass # Do nothing

if rangelist[1] == 2:
    print("The second item (lists are 0-based) is 2")
elif rangelist[1] == 3:
    print("The second item (lists are 0-based) is 3")
else:
    print("Dunno")

while rangelist[1] == 1:
    print("We are trapped in an infinite loop!")

Les fonctions

Les fonctions sont déclarées avec le mot-clé def. Les arguments optionnels sont définis dans la déclaration de la fonction après les arguments obligatoires en étant attribués une valeur par défaut. Pour les arguments nommés, le nom de l'argument est attribué une valeur. Les fonctions peuvent retourner une tuple (et en utilisant le déballage de tuple, vous pouvez retourner efficacement plusieurs valeurs). Les fonctions lambda sont des fonctions ad hoc composées d'une seule instruction. Les paramètres sont passés par référence, mais les types immuables (tuples, int, chaînes, etc.) ne peuvent pas être modifiés dans l'appelant par l'appelant.

# Same as def funcvar(x): return x + 1
funcvar = lambda x: x + 1
>>> print(funcvar(1))
2

# an_int and a_string are optional, they have default values
# if one is not passed (2 and "A default string", respectively).
def passing_example(a_list, an_int=2, a_string="A default string"):
    a_list.append("A new item")
    an_int = 4
    return a_list, an_int, a_string

>>> my_list = [1, 2, 3]
>>> my_int = 10
>>> print(passing_example(my_list, my_int))
([1, 2, 3, 'A new item'], 4, "A default string")
>>> my_list
[1, 2, 3, 'A new item']
>>> my_int
10

Les classes

Python prend en charge une forme limitée d'héritage multiple dans les classes. Les variables privées et les méthodes peuvent être déclarées (par convention, cela n'est pas appliqué par le langage) en ajoutant un soulignement principal (par exemple _spam).

class MyClass(object):
    common = 10
    def __init__(self):
        self.myvariable = 3
    def myfunction(self, arg1, arg2):
        return self.myvariable

    # This is the class instantiation

>>> classinstance = MyClass()
>>> classinstance.myfunction(1, 2)
3
# This variable is shared by all instances.
>>> classinstance2 = MyClass()
>>> classinstance.common
10
>>> classinstance2.common
10
# Note how we use the class name
# instead of the instance.
>>> MyClass.common = 30
>>> classinstance.common
30
>>> classinstance2.common
30
# This will not update the variable on the class,
# instead it will bind a new object to the old
# variable name.
>>> classinstance.common = 10
>>> classinstance.common
10
>>> classinstance2.common
30
>>> MyClass.common = 50
# This has not changed, because "common" is
# now an instance variable.
>>> classinstance.common
10
>>> classinstance2.common
50

# This class inherits from MyClass. The example
# class above inherits from "object", which makes
# it what's called a "new-style class".
# Multiple inheritance is declared as:
# class OtherClass(MyClass1, MyClass2, MyClassN)
class OtherClass(MyClass):
    # The "self" argument is passed automatically
    # and refers to the class instance, so you can set
    # instance variables as above, but from inside the class.
    def __init__(self, arg1):
        self.myvariable = 3
        print(arg1)

>>> classinstance = OtherClass("hello")
hello
>>> classinstance.myfunction(1, 2)
3
# This class doesn't have a .test member, but
# we can add one to the instance anyway. Note
# that this will only be a member of classinstance.
>>> classinstance.test = 10
>>> classinstance.test
10

Exceptions

Les exceptions en Python sont gérées avec des blocs try-except [nom d'exception]:

def some_function():
    try:
        # Division by zero raises an exception
        10 / 0
    except ZeroDivisionError:
        print("Oops, invalid.")
    else:
        # Exception didn't occur, we're good.
        pass
    finally:
        # This is executed after the code block is run
        # and all exceptions have been handled, even
        # if a new exception is raised while handling.
        print("We're done with that.")

>>> some_function()
Oops, invalid.
We're done with that.

Importation

Les bibliothèques externes sont utilisées avec le mot clé import [libname]. Vous pouvez également utiliser from [libname] import [funcname] pour des fonctions individuelles. Voici un exemple:

import random
from time import clock

randomint = random.randint(1, 100)
>>> print(randomint)
64

Fichier d'entrée/sortie

Python a un large éventail de bibliothèques intégrées. À titre d'exemple, voici comment la sérialisation (conversion de structures de données en chaînes à l'aide de la bibliothèque pickle) avec l'E/S de fichier est utilisée:

import pickle
mylist = ["This", "is", 4, 13327]
# Open the file C:\\binary.dat for writing. The letter r before the
# filename string is used to prevent backslash escaping.
myfile = open(r"C:\\binary.dat", "wb")
pickle.dump(mylist, myfile)
myfile.close()

myfile = open(r"C:\\text.txt", "w")
myfile.write("This is a sample string")
myfile.close()

myfile = open(r"C:\\text.txt")
>>> print(myfile.read())
'This is a sample string'
myfile.close()

# Open the file for reading.
myfile = open(r"C:\\binary.dat", "rb")
loadedlist = pickle.load(myfile)
myfile.close()
>>> print(loadedlist)
['This', 'is', 4, 13327]

autres

• Les conditions peuvent être enchaînées: 1 < a < 3 vérifie que a est à la fois inférieur à 3 et supérieur à 1.
• Vous pouvez utiliser del pour supprimer des variables ou des éléments dans des tableaux.
• Les compréhensions de liste fournissent un moyen puissant de créer et manipuler des listes. Elles consistent en une expression suivie d'une clause for suivie de zéro ou plus de clauses if ou for, comme ceci:

>>> lst1 = [1, 2, 3]
>>> lst2 = [3, 4, 5]
>>> print([x * y for x in lst1 for y in lst2])
[3, 4, 5, 6, 8, 10, 9, 12, 15]
>>> print([x for x in lst1 if 4 > x > 1])
[2, 3]
# Check if a condition is true for any items.
# "any" returns true if any item in the list is true.
>>> any([i % 3 for i in [3, 3, 4, 4, 3]])
True
# This is because 4 % 3 = 1, and 1 is true, so any()
# returns True.

# Check for how many items a condition is true.
>>> sum(1 for i in [3, 3, 4, 4, 3] if i == 4)
2
>>> del lst1[0]
>>> print(lst1)
[2, 3]
>>> del lst1

• Les variables globales sont déclarées en dehors des fonctions et peuvent être lues sans aucune déclaration spéciale, mais si vous voulez leur écrire, vous devez les déclarer au début de la fonction avec le mot clé global, sinon Python liera cet objet à une nouvelle variable locale (attention, c'est un petit piège qui peut vous arriver si vous ne le savez pas).

number = 5

def myfunc():
    # This will print 5.
    print(number)

def anotherfunc():
    # This raises an exception because the variable has not
    # been bound before printing. Python knows that it an
    # object will be bound to it later and creates a new, local
    # object instead of accessing the global one.
    print(number)
    number = 3

def yetanotherfunc():
    global number
    # This will correctly change the global.
    number = 3

Épilogue

Ce tutoriel n'est pas destiné à être une liste exhaustive de tous (ou même d'un sous-ensemble) de Python. Python a un large éventail de bibliothèques et beaucoup plus de fonctionnalités que vous devrez découvrir par d'autres moyens, comme l'excellent livre Dive into Python. J'espère que j'ai facilité votre transition en Python. S'il vous plaît laissez des commentaires si vous pensez qu'il y a quelque chose qui pourrait être amélioré ou ajouté ou s'il y a autre chose que vous aimeriez voir (classes, traitement des erreurs, n'importe quoi).