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
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
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
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
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
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 :
...
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
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
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
#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
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
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
# 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
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
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
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
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
3-element Array{Int64,1}:
1
2
3
julia> filter(x -> x % 2 == 0, array)
1-element Array{Int64,1}:
2