Les bases en

À propos de Les bases

Python est un langage de programmation dynamiquement et fortement typé. Il utilise à la fois le duck typing et le typage progressif, via les annotations de type. Les styles de programmation impératif, déclaratif (par exemple fonctionnel) et orienté objet sont tous pris en charge, mais en interne, tout en Python est un objet.

Python met fortement l'accent sur la lisibilité du code et (comme Haskell) utilise l'indentation significative pour délimiter les définitions de fonctions, de méthodes et de classes.

Python a été créé par Guido van Rossum et publié pour la première fois en 1991. La Python Software Foundation gère et oriente les ressources destinées au développement de Python et de CPython, et reçoit les propositions de modification du langage de la part des membres de la communauté via les Python Enhancement Proposals, ou PEP.

La documentation complète de la version actuelle se trouve sur docs.python.org.

• Tutoriel Python
• Référence de la bibliothèque Python
• Référence du langage Python
• HOW TOs Python
• FAQ Python
• Glossaire des termes Python

Ce premier concept présente 4 fonctionnalités majeures du langage Python :

1. L'affectation de noms (variables et constantes),
2. Les fonctions (le mot-clé def et le mot-clé return),
3. Les commentaires, et
4. Les docstrings.

L'affectation de noms (variables et constantes)

En Python, aucun mot-clé n'est utilisé pour créer des variables ou des constantes. À la place, on peut lier des noms (aussi appelés variables) à n'importe quel type d'objet à l'aide de l'opérateur d'affectation = : <name> = <value>. Un nom peut être réaffecté (ou relié à nouveau) à différentes valeurs (différents types d'objets) au cours de sa durée de vie.

Par exemple, my_first_variable peut être réaffecté de nombreuses fois avec =, et peut désigner des types d'objets différents à chaque réaffectation :

>>> my_first_variable = 1  # my_first_variable bound to an integer object of value one.
>>> my_first_variable = 2  # my_first_variable re-assigned to integer value 2.

>>> print(type(my_first_variable))
<class 'int'>

>>> print(my_first_variable)
2

>>> my_first_variable = "Now, I'm a string." # <--You may re-bind a name to a different object type and value.
>>> print(type(my_first_variable))
<class 'str'>

>>> my_first_variable = 'You can call me "str".' # <--Strings can be declared using single or double quote marks.
>>> print(my_first_variable)
You can call me "str".

>>> import collections
>>> my_first_variable = collections.Counter([1,1,2,3,3,3,4,5,6,7]) # <--Now my_first_variable has been re-bound to a Counter object.
>>> print(type(my_first_variable))
<class 'collections.Counter'>

>>> print(my_first_variable)
Counter({3: 3, 1: 2, 2: 1, 4: 1, 5: 1, 6: 1, 7: 1})

Les constantes

Les constantes sont des noms destinés à n'être affectés qu'une seule fois dans un programme. Elles doivent être définies au niveau d'un module (fichier), et sont généralement visibles par toutes les fonctions et classes du programme. L'utilisation de SCREAMING_SNAKE_CASE indique que le nom ne doit pas être réaffecté, ni sa valeur modifiée.

# All caps signal that this is intended as a constant.
MY_FIRST_CONSTANT = 16

# Re-assignment will be allowed by the compiler & interpreter,
# but this is VERY strongly discouraged.
# Please don't do this, it could create problems in your program!
MY_FIRST_CONSTANT = "Some other value"

Les fonctions

En Python, les unités de fonctionnalité sont encapsulées dans des fonctions, qui sont elles-mêmes des objets (c'est des tortues jusqu'en bas).

Les fonctions peuvent être exécutées seules, passées en arguments à d'autres fonctions, imbriquées ou liées à une classe. Lorsque des fonctions sont liées au nom d'une classe, on les appelle des méthodes. Les fonctions et classes liées (avec leurs méthodes) peuvent être regroupées dans le même fichier ou module, et importées en partie ou en totalité pour être utilisées dans d'autres programmes.

Le mot-clé def commence une définition de fonction. Chaque fonction peut prendre zéro ou plusieurs paramètres formels entre parenthèses (), suivis d'un deux-points :. Les instructions qui forment le corps de la fonction commencent sur la ligne qui suit def et doivent être indentées en bloc :

# The body of a function is indented by 2 spaces & prints the sum of the numbers.
def add_two_numbers(number_one, number_two):
  total = number_one + number_two
  print(total)  

>>> add_two_numbers(3, 4)
7


# Inconsistent indentation in your code blocks will raise an error.
>>> def add_three_numbers_misformatted(number_one, number_two, number_three):
...     result = number_one + number_two + number_three   # This was indented by 4 spaces.
...    print(result)     # <--This was only indented by 3 spaces.
...
...
  File "<stdin>", line 3
    print(result)
    ^
IndentationError: unindent does not match any outer indentation level

Les fonctions renvoient explicitement une valeur ou un objet via le mot-clé return :

# Function definition on first line, explicit return used on final line.
def add_two_numbers(number_one, number_two):
  return number_one + number_two   


# Calling the function in the Python shell returns the sum of the numbers.
>>> add_two_numbers(3, 4)
7

# Assigning the function call to a variable and printing 
# the variable will also return the value.
>>> sum_with_return = add_two_numbers(5, 6)
>>> print(sum_with_return)
11

Les fonctions qui n'ont pas d'expression explicite après un return renvoient implicitement l'objet None. Les détails de None seront abordés dans un prochain concept. Pour les besoins de cet exercice et de cette explication, None est un espace réservé qui ne représente rien, ou null :

# This function will return `None`
def square_a_number(number):
    square = number * number
    return # <-- note that this return is not followed by an expression

# Calling the function in the Python shell appears 
# to not return anything at all.
>>> square_a_number(2)
>>>


# Using print() with the function call shows that 
# the function is actually returning the **None** object.
>>> print(square_a_number(2))
None

Les fonctions qui omettent return renvoient elles aussi implicitement l'objet None. Cela signifie que si tu n'utilises pas return dans une fonction, Python renvoie l'objet None à ta place.

# This function omits a return keyword altogether
def add_two_numbers(number_one, number_two):
  result = number_one + number_two

>>> add_two_numbers(5, 7)
>>> print(add_two_numbers(5, 7))
None

# Assigning the function call to a variable and printing 
# the variable will also show None.
>>> sum_without_return = add_two_numbers(5, 6)
>>> print(sum_without_return)
None

Appeler des fonctions

Les fonctions sont appelées en utilisant leur nom suivi de parenthèses (). La notation pointée (.) sert à appeler les fonctions définies à l'intérieur d'une classe ou d'un module.

>>> def raise_to_power(number, power):
...     return number ** power
...

>>> raise_to_power(3,3) # Invoking the function with the arguments 3 and 3.
27


# A mis-match between the number of parameters and the number of arguments will raise an error.
>>> raise_to_power(4,)
...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: raise_to_power() missing 1 required positional argument: 'power'


# Calling methods or functions in classes and modules.
>>> start_text = "my silly sentence for examples."
>>> str.upper(start_text)  # <--Calling the upper() method from the built-in str class on start_text.
'MY SILLY SENTENCE FOR EXAMPLES.'

# Because a string is an instance of the str class, methods can also be called on them "directly".
>>> start_text = "my silly sentence for examples."
>>> start_text.upper()  # <--Calling the upper() method on start_text directly.
'MY SILLY SENTENCE FOR EXAMPLES.'

# Alternatively, we can skip the variable assignment (although this gets messy quick).
>>> "my silly sentence for examples.".upper()
'MY SILLY SENTENCE FOR EXAMPLES.'


# Importing the math module
>>> import math
>>> math.pow(2,4)  # <--Calling the pow() function from the math module.
16.0

Les commentaires

Les commentaires en Python commencent par un # qui ne fait pas partie d'une string, et se terminent à la fin de la ligne. Contrairement à de nombreux autres langages de programmation, Python ne prend pas en charge les marques de commentaire multilignes. Chaque ligne d'un bloc de commentaire doit commencer par le caractère #.

Les commentaires sont ignorés par l'interprète :

# This is a single line comment.

x = "foo"  # This is an in-line comment.

# This is a multi-line
# comment block over multiple lines --
# these should be used sparingly.

Les docstrings

La première instruction du corps d'une fonction peut éventuellement être une docstring, qui résume de façon concise la raison d'être de la fonction ou de l'objet. Les docstrings sont déclarées à l'aide de triples guillemets doubles (""") indentés au même niveau que le bloc de code :

# An example from PEP257 of a multi-line docstring
# reformatted to use Google style non-type hinted docstrings.
# Some additional details can be found in the Sphinx documentation:
# https://www.sphinx-doc.org/en/master/usage/extensions/napoleon.html#getting-started

def complex(real=0.0, imag=0.0):
    """Form a complex number.

    Keyword Arguments:
        real (float): The real part of the number (default 0.0)
        imag (float): The imaginary part of the number (default 0.0)
        
    """

    if imag == 0.0 and real == 0.0:
        return complex_zero

Les docstrings sont lues par les outils de documentation automatisée et sont renvoyées en appelant l'attribut spécial .__doc__ sur le nom de la fonction, de la méthode ou de la classe. Elles sont recommandées pour les programmes de toute taille qui nécessitent de la documentation, et leurs conventions sont décrites dans la PEP257.

Les docstrings peuvent aussi servir de tests unitaires légers, qui peuvent être lus et exécutés par PyTest, ou en important le module doctest. Les tests et doctest seront abordés dans un prochain concept.

# An example on a user-defined function using a Google style docstring. 
>>> def raise_to_power(number, power):
    """Raise a number to an arbitrary power.

    Parameters:
        number (int): The base number.
        power (int): The power to raise the base number to.
    
    Returns:
        int: The number raised to the specified power.
    
    Takes a number and raises it to the specified power, returning the result.

    """

    return number ** power
...

# Calling the .__doc__ attribute of the function and printing the result.
>>> print(raise_to_power.__doc__)
Raise a number to an arbitrary power.

Parameters:
    number (int): The base number.
    power (int): The power to raise the base number to.

Returns:
    int: The number raised to the specified power.

Takes a number and raises it to the specified power, returning the result.

...

# Printing the __doc__ attribute of the built-in type: str.
>>> print(str.__doc__)
str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or
errors is specified, then the object must expose a data buffer
that will be decoded using the given encoding and error handler.
Otherwise, returns the result of object.__str__() (if defined)
or repr(object).
encoding defaults to 'utf-8'.
errors defaults to 'strict'.