Aperçu

Vous étudierez la grammaire de base de Python 3 en vous référant à «Introduction à Python 3» par O'Reilly Japan. J'espère que cela sera utile pour ceux qui veulent étudier Python de la même manière.

Utilisation de base des fonctions

Définition des fonctions

>>> def print_sum(num1, num2):
...     print(num1 + num2)

Appel de fonction

>>> print_sum(10, 20)
30

Les arguments utilisés dans la définition de la fonction sont des arguments formels (paramètre), L'argument passé au moment de l'appel est appelé argument réel (argument).

Argument de position

Un argument qui copie une valeur dans un argument formel à la position correspondante dans l'ordre depuis le début est appelé "argument de position".

>>> def print_args(arg1, arg2, arg3):
...     print('arg1:', arg1, 'arg2:', arg2, 'arg3:', arg3)
...
>>> print_args(1111, True, 'Python')
arg1: 1111 arg2: True arg3: Python

Argument de mot-clé

Vous pouvez également spécifier l'argument réel en spécifiant le nom de l'argument formel, auquel cas il sera traité comme un "argument mot-clé".

>>> def print_args(arg1, arg2, arg3):
...     print('arg1:', arg1, 'arg2:', arg2, 'arg3:', arg3)
...
>>> print_args(arg2='two', arg1='one', arg3='three')
arg1: one arg2: two arg3: three

Spécification de la valeur d'argument par défaut

Vous pouvez également spécifier une valeur par défaut pour l'argument formel. La valeur par défaut est utilisée si l'appelant ne transmet pas l'argument réel correspondant.

>>> def print_args(arg1, arg2, arg3='default value'):
...     print('arg1:', arg1, 'arg2:', arg2, 'arg3:', arg3)
...
>>> #Si la valeur par défaut est utilisée (aucun argument réel n'est passé)
>>> print_args('one', 'two')
arg1: one arg2: two arg3: default value
>>>
>>> #Si la valeur par défaut n'est pas utilisée (en passant l'argument réel)
>>> print_args('one', 'two', 'three')
arg1: one arg2: two arg3: three

Tapling d'arguments positionnels avec *

Si * est utilisé dans le cadre de l'argument formel lors de la définition d'une fonction, un nombre variable d'arguments positionnels est mis ensemble dans un taple.

>>> def print_args(*args):
...     print('args tuple:', args)
...
>>> #Spécifiez plusieurs arguments
>>> print_args('one', 'two', 'three')
args tuple: ('one', 'two', 'three')
>>>
>>> #Aucun argument
>>> print_args()
args tuple: ()

S'il existe un argument positionnel requis, l'utilisation suivante est également possible.

>>> def print_args(arg1, arg2, *args):
...     print('arg1:', arg1)
...     print('arg2:', arg2)
...     print('args:', args)
...
>>> print_args('one', 'two', 1, 10, 100)
arg1: one
arg2: two
args: (1, 10, 100)

Dictionnaire des arguments de mots clés par **

Si vous utilisez ** lors de la définition d'une fonction, vous pouvez définir des arguments de mot-clé collectivement dans un dictionnaire.

>>> def print_kwargs(**kwargs):
...     print('kwargs:', kwargs)
...
>>> print_kwargs(arg1='one', arg2='two', arg3='three')
kwargs: {'arg1': 'one', 'arg2': 'two', 'arg3': 'three'}

Définir la fonction comme argument

Vous pouvez traiter la fonction comme un argument de la fonction ou renvoyer la fonction comme valeur de retour de la fonction.

>>> def print_string():
...     print('print_string')
...
>>> def execute_func(arg_func):
...     arg_func()
...
>>> execute_func(print_string)
print_string

Fonction en fonction

Vous pouvez également définir une fonction à l'intérieur d'une fonction.

>>> def outer():
...     def inner():
...         print('inner function')
...     inner()
...
>>> outer()
inner function

fermeture

Il est également possible de faire fonctionner une fonction en fonction comme une fermeture et de générer dynamiquement une fonction.

>>> def todays_weather(arg1):
...     def return_weather():
...         return 'It’s ' +  arg1 + ' today.'
...     return return_weather
...
>>> day1 = todays_weather('sunny')
>>> day2 = todays_weather('cloudy')
>>>
>>> day1()
'It’s sunny today.'
>>> day2()
'It’s cloudy today.'

Fonction Lambda

Implémentation sans fonction lambda

>>> def return_sum(num1, num2):
...     return num1 + num2
...
>>> print('answer:', return_sum(10, 20))
answer: 30

Implémentation à l'aide de la fonction lambda

>>> return_sum = lambda num1, num2 :num1 + num2
>>> print('answer:', return_sum(10, 20))
answer: 30

Exemple d'utilisation de la fonction lambda en combinaison avec map ()

Lorsqu'il est combiné avec map (), les éléments itérables tels que la liste passée en argument, L'implémentation suivante qui le transmet à func et traite il est également possible. (* 1)

[Une addition]

1: Uniquement lors du renvoi d'une valeur, le contenu n'est qu'une expression et les instructions (if statement, for statement, while statement, etc.) ne peuvent pas être écrites. [/ Addenda]

https://docs.python.jp/3/library/functions.html#map

>>> help(map)
Help on class map in module builtins:

class map(object)
 |  map(func, *iterables) --> map object
 |
 |  Make an iterator that computes the function using arguments from
 |  each of the iterables.  Stops when the shortest iterable is exhausted.

Exemple d'implémentation

>>> num_list = list(range(1, 6))
>>> num_list
[1, 2, 3, 4, 5]
>>>
>>> list(map(lambda x: x**2, num_list))
[1, 4, 9, 16, 25]

Grammaire de base du système Python3 (comment utiliser les fonctions, la fermeture, la fonction lambda)