Julia Fonctions

Une fonction est un ensemble d'instructions qui, ensemble, accomplissent une tâche.

En Julia, une fonction est un objet qui associe un tuple de valeurs d'arguments à une valeur de retour.

En Julia, utilisezfunctionLa syntaxe de base pour définir une fonction est :

function functionname(args)
   expression
   expression
   expression
   ...
   expression
end

Par défaut, la valeur renvoyée par une fonction est la valeur de la dernière expression évaluée, vous pouvez donc voir ci-dessus qu'il n'y a pas dereturninstruction. Bien sûr, si vous utilisez lereturnmot-clé, la fonction retournera immédiatement :.

Exemple

julia> function f(x,y)
           x + y
       end
f (fonction générique avec 1 méthode)
julia> f(2,3)
5

julia> function bills(money)
      if money < 0
         return false
      else
         return true
      end
   end
bills (generic function with 1 method)

julia> bills(50)
vrai

julia> bills(-50)
false

Si une fonction doit renvoyer plusieurs valeurs, vous pouvez utiliser un tuple :

Exemple

julia> function mul(x,y)
                  x+y, x*y
               end
mul (fonction générique avec 1 méthode)

julia> mul(5, 10)
(15, 50)

Lorsqu'une fonction ne contient qu'une seule expression, vous pouvez omettre le mot-cléfunction, définir le nom de la fonction et les paramètres du côté gauche du signe égal, et définir l'expression du côté droit, comme une forme d'affectation :

julia> f(x,y) = x + y
f (generic function with 1 method)

Lorsqu'il n'y a pas de parenthèses, l'expressionffait référence à l'objet fonction, qui peut être transmis comme n'importe quelle valeur :

julia> g = f;
julia> g(2,3)
5

Exemple

julia> f(a) = a * a
f (fonction générique avec 1 méthode)

julia> f(5)
25

julia> func(x, y) = sqrt(x^2 + y^2)
func (fonction générique avec 1 méthode)

julia> func(5, 4)
6.4031242374328485

Comme les noms de variables, les caractères Unicode peuvent également être utilisés comme noms de fonctions :

julia> ∑(x,y) = x + y
∑ (generic function with 1 method)

julia> ∑(2, 3)
5

Type de retour

Nous pouvons utiliser l'::opérateur pour spécifier le type de retour de la fonction.

Exemple

julia> function g(x, y)::Int8
           return x * y
       end;

julia> typeof(g(1, 2))
Int8

L'exemple de fonction ci-dessus ignore les types de x et y et renvoie une valeur de type Int8.

Arguments optionnels

Dans les fonctions, nous pouvons définir des valeurs par défaut pour les paramètres, de sorte que, lorsque le paramètre n'est pas fourni, la valeur par défaut puisse être utilisée pour le calcul :

L'exemple suivant définit une fonction pos avec trois paramètres, où le paramètre cz a une valeur par défaut de 0. Lors de l'appel de la fonction, ce paramètre peut être omis :

Exemple

julia> function pos(ax, by, cz=0)
         println("$ax, $by, $cz")
      end
pos (fonction générique avec 2 méthodes)

julia> pos(10, 30)
10, 30, 0

julia> pos(10, 30, 50)
10, 30, 50

Arguments par mot-clé

Parfois, les fonctions que nous définissons nécessitent un grand nombre d'arguments, mais appeler ces fonctions peut être pénible car nous pouvons oublier l'ordre dans lequel fournir les arguments. Par exemple :

function foo(a, b, c, d, e, f)
...
end

Nous pourrions oublier l’ordre des arguments, ce qui donnerait l’appel de fonction suivant :

foo("25", -5.6987, "hello", 56, good, 'ABC')
或
foo("hello", 56, "25", -5.6987, 'ABC', good)

Cela semble très déroutant.

Les arguments par mot-clé de Julia permettent d’identifier les arguments par leur nom plutôt que seulement par leur position, ce qui rend ces fonctions complexes faciles à utiliser et à étendre.

Pour marquer des arguments par mot-clé, vous devez utiliser un point-virgule après les arguments non marqués de la fonction;, suivi d’une ou plusieurs paires clé-valeurkey=value, comme montré ci-dessous :

Exemple

julia> function foo(a, b ; c = 10, d = "hi")
         println("a is $a")
         println("b is $b")
         return "c => $c, d => $d"
      end
foo (fonction générique avec 1 méthode)

julia> foo(100,20)
a est 100
b est 20
"c => 10, d => hi"

julia> foo("Hello", "Example", c=pi, d=22//7)
a est Hello
b est Example
"c => π, d => 22//7"

Avec des arguments nommés, la position des arguments n'est pas si importante. Nous pouvons également appeler la fonction ci-dessus comme ceci :

Exemple

julia> foo(c=pi, d =22/7, "Hello", "Example")
a est Hello
b est Example
"c => π, d => 3.142857142857143"

Fonctions anonymes

Une fonction anonyme est une fonction sans nom de fonction.

Les fonctions anonymes sont déclarées dynamiquement à l'exécution. À part le fait de ne pas avoir de nom de fonction, elles sont identiques aux fonctions standard.

En Julia, les fonctions anonymes peuvent être utilisées à de nombreux endroits, comme map() et les compréhensions de listes.

Après avoir utilisé des fonctions anonymes, notre code devient plus concis.

La syntaxe des fonctions anonymes utilise le symbole->。

Exemple

julia> x -> x^2 + 2x - 1
#1 (fonction générique avec 1 méthode)

julia> function (x)
           x^2 + 2x - 1
       end
#3 (fonction générique avec 1 méthode)

L'exemple ci-dessus crée une fonction qui accepte un paramètrexet renvoie le polynôme de la valeur actuellex^2+2x-1fonction.

L'utilisation principale des fonctions anonymes est de les passer à des fonctions qui reçoivent des fonctions en arguments. Un exemple classique est map, qui applique une fonction à chaque élément d'un tableau puis renvoie un nouveau tableau contenant les valeurs résultantes :

Exemple

julia> map(round, [1.2, 3.5, 1.7])
3-élément Vector{Float64}:
 1.0
 4.0
 2.0

Si la fonction de transformation passée comme premier argument à map existe déjà, utiliser directement le nom de la fonction convient. Mais généralement, la fonction à utiliser n'a pas encore été définie, donc utiliser une fonction anonyme est plus pratique :

Exemple

julia> map(x -> x^2 + 2x - 1, [1, 3, -1])
3-element Vector{Int64}:
  2
 14
 -2

Les fonctions anonymes qui acceptent plusieurs arguments peuvent être écrites avec la syntaxe (x,y,z)->2x+y-z, tandis que les fonctions anonymes sans argument s'écrivent ()->3. Cette façon d'écrire des fonctions sans argument peut sembler un peu étrange, mais elle est très nécessaire pour l'évaluation paresseuse. Cet usage enveloppe un bloc de code dans une fonction sans argument et l'appelle ensuite comme f.

Par exemple, considérez l'appel à get :

Exemple

get(dict, key) do
    # valeur par défaut calculée ici
    time()
end

Le code ci-dessus équivaut à appeler get avec une fonction anonyme contenant le code. Il est enveloppé entre do et end, comme montré ci-dessous :

get(()->time(), dict, key)

Ici, l'appel à time est retardé par une fonction anonyme sans argument qui l'enveloppe. Cette fonction anonyme n'est appelée que lorsque dict ne contient pas la clé demandée.


Imbrication de fonctions et récursivité

En Julia, les fonctions peuvent être imbriquées.

L'exemple suivant imbrique une fonction add1 dans la fonction add() :

Exemple

julia> function add(x)
         Y = x * 2
         function add1(Y)
           Y += 1
         end
         add1(Y)
       end
add (generic function with 1 method)

julia> d = 10
10

julia> add(d)
21

De même, les fonctions en Julia peuvent aussi être récursives.

La récursivité désigne la méthode consistant à utiliser la fonction elle-même dans la définition d'une fonction.

Par exemple :
Il était une fois une montagne, dans la montagne il y avait un temple, dans le temple il y avait un vieux moine qui racontait une histoire à un jeune moine ! Quelle était l'histoire ? « Il était une fois une montagne, dans la montagne il y avait un temple, dans le temple il y avait un vieux moine qui racontait une histoire à un jeune moine ! Quelle était l'histoire ? 'Il était une fois une montagne, dans la montagne il y avait un temple, dans le temple il y avait un vieux moine qui racontait une histoire à un jeune moine ! Quelle était l'histoire ? ...' »

Ci-dessous, nous utilisons l'opérateur ternaire pour tester la récursivité. L'opérateur ternaire agit sur trois opérandesexpr ? a : b, si expr est vrai, la valeur est le résultat de l'évaluation de a, sinon c'est le résultat de l'évaluation de b.

Exemple

julia> sum(x) = x > 1 ? sum(x-1) + x : x
sum (generic function with 1 method)

julia> sum(10)
55

L'exemple ci-dessus sert à calculer la somme de tous les nombres jusqu'à un certain entier inclus. Dans cette récursion, comme il y a un cas de base, c'est-à-dire lorsque x vaut 1, cette valeur est renvoyée.

L'exemple le plus célèbre de récursion est le calcul du n-ième nombre de Fibonacci. La suite de Fibonacci est une suite comme ceci : 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368........

À partir du 3e terme, chaque terme de cette suite est égal à la somme des deux termes précédents.

Exemple

julia> fib(x) = x < 2 ? x : fib(x-1) + fib(x-2)
fib (fonction générique function avec 1 méthode)

julia> fib(10)
55

julia> fib(20)
6765

Map

Le format de définition de Map est le suivant :

map(func, coll)

Ici, func est une fonction qui est appliquée successivement à chaque élément de la collection coll. Map contient généralement une fonction anonyme et renvoie une nouvelle collection.

Exemple

julia> map(A -> A^3 + 3A - 3, [10,3,-2])
3-element Array{Int64,1}:
 1027
   33
  -17

Filter

Le format de définition de Filter est le suivant :

filter(function, collection)

La fonction filter renvoie une copie de la collection, en supprimant les éléments pour lesquels le résultat de l'appel de la fonction est false.

Exemple

julia> array = Int[1,2,3]
3-element Array{Int64,1}:
 1
 2
 3
 
julia> filter(x -> x % 2 == 0, array)
1-element Array{Int64,1}:
 2
Autres extensions