Überblick

Sie lernen die grundlegende Grammatik des Python 3-Systems unter "Einführung Python 3" von O'Reilly Japan. Ich hoffe, es ist hilfreich für diejenigen, die Python auf die gleiche Weise lernen möchten.

Grundlegende Verwendung von Funktionen

Funktionsdefinition

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

Funktionsaufruf

>>> print_sum(10, 20)
30

Die in der Funktionsdefinition verwendeten Argumente sind formale Argumente (Parameter), Das zum Zeitpunkt des Aufrufs übergebene Argument wird als tatsächliches Argument (Argument) bezeichnet.

Positionsargument

Ein Argument, das von Anfang an einen Wert in ein formales Argument an der entsprechenden Position kopiert, wird als "Positionsargument" bezeichnet.

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

Schlüsselwortargument

Sie können das tatsächliche Argument auch angeben, indem Sie den Namen des formalen Arguments angeben. In diesem Fall wird es als "Schlüsselwortargument" behandelt.

>>> 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

Angabe des Standardargumentwerts

Sie können auch einen Standardwert für das formale Argument angeben. Der Standardwert wird verwendet, wenn der Aufrufer das entsprechende tatsächliche Argument nicht übergibt.

>>> def print_args(arg1, arg2, arg3='default value'):
...     print('arg1:', arg1, 'arg2:', arg2, 'arg3:', arg3)
...
>>> #Wenn der Standardwert verwendet wird (kein tatsächliches Argument übergeben)
>>> print_args('one', 'two')
arg1: one arg2: two arg3: default value
>>>
>>> #Wenn der Standardwert nicht verwendet wird (Übergabe des eigentlichen Arguments)
>>> print_args('one', 'two', 'three')
arg1: one arg2: two arg3: three

Tapling von Positionsargumenten mit *

Wenn * beim Definieren einer Funktion als Teil des formalen Arguments verwendet wird, wird eine variable Anzahl von Positionsargumenten in einem Taple zusammengefasst.

>>> def print_args(*args):
...     print('args tuple:', args)
...
>>> #Geben Sie mehrere Argumente an
>>> print_args('one', 'two', 'three')
args tuple: ('one', 'two', 'three')
>>>
>>> #Keine Argumente
>>> print_args()
args tuple: ()

Wenn ein Positionsargument erforderlich ist, können Sie es auch wie folgt verwenden.

>>> 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)

Wörterbuch der Schlüsselwortargumente von **

Wenn Sie beim Definieren einer Funktion ** verwenden, können Sie Schlüsselwortargumente gemeinsam in einem Wörterbuch festlegen.

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

Funktion als Argument festlegen

Sie können die Funktion als Argument der Funktion behandeln oder die Funktion als Rückgabewert der Funktion zurückgeben.

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

In-Funktion-Funktion

Sie können auch eine Funktion innerhalb einer Funktion definieren.

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

Schließung

Es ist auch möglich, eine funktionsinterne Funktion als Abschluss zu verwenden und dynamisch eine Funktion zu generieren.

>>> 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.'

Lambda-Funktion

Implementierung ohne Lambda-Funktion

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

Implementierung mit Lambda-Funktion

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

Beispiel für die Verwendung der Lambda-Funktion in Kombination mit map ()

In Kombination mit map () können iterable Elemente wie die als Argument übergebene Liste Die folgende Implementierung, die es an func weitergibt und verarbeitet, ist ebenfalls möglich. (* 1)

[Zusatz]

1: Nur wenn ein Wert zurückgegeben wird, ist der Inhalt nur ein Ausdruck, und Anweisungen (if-Anweisung, for-Anweisung, while-Anweisung usw.) können nicht geschrieben werden. [/ Nachtrag]

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.

Implementierungsbeispiel

>>> 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]

Grundlegende Grammatik des Python3-Systems (Verwendung von Funktionen, Schließung, Lambda-Funktion)