Note: Python における日付は、独自のデータ型ではなく、日付オブジェクトとして扱うために datetime モジュールをインポートします。
Pythonにおける日付は独自のデータ型ではなく、日付オブジェクトとして扱うために datetime モジュールをインポートします。
datetime モジュールをインポートし、現在の日付を表示します：
import datetime
x = datetime.datetime.now()
print(x)
上記の例のコードを実行すると、次の結果が得られます：
2024-07-09 11:25:56.518891日付には年、月、日、時、分、秒、マイクロ秒が含まれます。
datetime モジュールには、日付オブジェクトに関する情報を返す多くのメソッドがあります。
以下にいくつかの例を示しますが、この章の後半で詳しく学びます：
年と曜日名を返します：
import datetime
x = datetime.datetime.now()
print(x.year)
print(x.strftime("%A"))
日付を作成するには、datetime モジュールの datetime() クラス（コンストラクタ）を使用します。
datetime() クラスには、年、月、日の3つのパラメータが必要です：
日付オブジェクトを作成します：
import datetime
x = datetime.datetime(2020, 5, 17)
print(x)
datetime() クラスは、時間とタイムゾーン（時、分、秒、マイクロ秒、タイムゾーンの tzone）のパラメータも受け取りますが、これらはオプションで、デフォルト値は 0 です（タイムゾーンには None）。
datetime オブジェクトには、日付オブジェクトを読みやすい文字列にフォーマットするためのメソッドがあります。
このメソッドは strftime() と呼ばれ、戻り値の文字列のフォーマットを指定するために format パラメータを取ります：
月の名前を表示します：
import datetime
x = datetime.datetime(2018, 6, 1)
print(x.strftime("%B"))
すべての有効なフォーマットコードの参照：
| ディレクティブ | 説明 | 例 |
|---|---|---|
| %a | 曜日の短いバージョン | Wed |
| %A | 曜日の完全なバージョン | Wednesday |
| %w | 曜日を 0-6 の数字で表現（0 は日曜日） | 3 |
| %d | 月の日付 01-31 | 31 |
| %b | 月の名前の短いバージョン | Dec |
| %B | 月の名前の完全なバージョン | December |
| %m | 月を 01-12 の数字で表現 | 12 |
| %y | 世紀を含まない年の短いバージョン | 18 |
| %Y | 年の完全なバージョン | 2018 |
| %H | 時間を 00-23 で表現 | 17 |
| %I | 時間を 00-12 で表現 | 05 |
| %p | AM/PM | PM |
| %M | 分を 00-59 で表現 | 41 |
| %S | 秒を 00-59 で表現 | 08 |
| %f | マイクロ秒を 000000-999999 で表現 | 548513 |
| %z | UTC オフセット | +0100 |
| %Z | タイムゾーン | CST |
| %j | 年の日数 001-366 | 365 |
| %U | 年の週番号（週の最初が日曜日） 00-53 | 52 |
| %W | 年の週番号（週の最初が月曜日） 00-53 | 52 |
| %c | 日付と時刻のローカルバージョン | Mon Dec 31 17:41:00 2018 |
| %C | 世紀 | 20 |
| %x | 日付のローカルバージョン | 12/31/18 |
| %X | 時間のローカルバージョン | 17:41:00 |
| %% | パーセント記号 | % |
| %G | ISO 8601 年 | 2018 |
| %u | ISO 8601 曜日（1-7） | 1 |
| %V | ISO 8601 週番号（01-53） | 01 |
Note: モジュールとは、コードライブラリと同じものと考えてください。
アプリケーションに含めたい関数のセットを含むファイルです。
モジュールを作成するには、拡張子 .py を持つファイルに必要なコードを保存します：
以下のコードを mymodule.py という名前のファイルに保存します：
def greeting(name):
print("Hello, " + name)
作成したモジュールを使うには、import ステートメントを使用します：
mymodule という名前のモジュールをインポートし、greeting 関数を呼び出します：
import mymodule
mymodule.greeting("Jonathan")
Note: モジュールから関数を使用する場合は、module_name.function_name の構文を使用します。
モジュールには関数だけでなく、あらゆるタイプの変数（配列、辞書、オブジェクトなど）を含めることができます：
以下のコードを mymodule.py ファイルに保存します：
person1 = {
"name": "John",
"age": 36,
"country": "Norway"
}
mymodule という名前のモジュールをインポートし、person1 辞書にアクセスします：
import mymodule
a = mymodule.person1["age"]
print(a)
モジュールファイルの名前は何でもかまいませんが、拡張子 .py を持つ必要があります。
モジュールをインポートする際に、as キーワードを使用してエイリアスを作成することができます：
mymodule に対するエイリアスとして mx を作成します：
import mymodule as mx
a = mx.person1["age"]
print(a)
Pythonにはいくつかの組み込みモジュールがあり、必要に応じていつでもインポートできます。
platform モジュールをインポートして使用します：
import platform
x = platform.system()
print(x)
モジュール内のすべての関数名（または変数名）をリストする組み込み関数があります。それが dir() 関数です：
platform モジュールに属するすべての定義済み名をリストします：
import platform
x = dir(platform)
print(x)
Note: dir() 関数はすべてのモジュールで使用でき、あなた自身で作成したモジュールも含まれます。
from キーワードを使用してモジュールの一部だけをインポートすることができます。
mymodule という名前のモジュールには1つの関数と1つの辞書があります：
def greeting(name):
print("Hello, " + name)
person1 = {
"name": "John",
"age": 36,
"country": "Norway"
}
モジュールから person1 辞書のみをインポートします：
from mymodule import person1
print(person1["age"])
Note: from キーワードを使用してインポートする場合、モジュール名は使用せず、モジュール内の要素を参照します。例：person1["age"]、mymodule.person1["age"] ではありません。
Note: 変数は作成された領域内でのみ利用可能です。これをスコープと呼びます。
関数内で作成された変数はその関数のローカルスコープに属し、その関数内でのみ使用できます。
関数内で作成された変数はその関数内で利用できます：
def myfunc():
x = 300
print(x)
myfunc()
上記の例で説明したように、変数 x は関数の外では利用できませんが、関数内の任意の関数からは利用できます：
ローカル変数は関数内の関数からアクセスできます：
def myfunc():
x = 300
def myinnerfunc():
print(x)
myinnerfunc()
myfunc()
Pythonコードのメイン部分で作成された変数はグローバル変数であり、グローバルスコープに属します。
グローバル変数はどのスコープからでも利用可能です。
関数の外で作成された変数はグローバルであり、誰でも利用できます：
x = 300
def myfunc():
print(x)
myfunc()
print(x)
関数の内外で同じ変数名を使用する場合、Pythonはそれらを別々の変数として扱います。一つはグローバルスコープ（関数の外）、もう一つはローカルスコープ（関数の内）です。
この関数はローカルの x を表示し、その後コードはグローバルの x を表示します：
x = 300
def myfunc():
x = 200
print(x)
myfunc()
print(x)
ローカルスコープに固執したままグローバル変数を作成する必要がある場合、global キーワードを使用できます。
global キーワードにより変数はグローバルスコープになります。
global キーワードを使用すると、変数はグローバルスコープに属します：
def myfunc():
global x
x = 300
myfunc()
print(x)
また、関数内でグローバル変数の値を変更する場合も、global キーワードを使用します。
関数内でグローバル変数の値を変更する場合は、global キーワードを使用して変数にアクセスします：
x = 300
def myfunc():
global x
x = 200
myfunc()
print(x)
nonlocal キーワードはネストした関数内で変数を扱う場合に使用されます。
nonlocal キーワードにより変数は外側の関数に属します。
nonlocal キーワードを使用すると、変数は外側の関数に属します：
def myfunc1():
x = "Jane"
def myfunc2():
nonlocal x
x = "hello"
myfunc2()
return x
print(myfunc1())
Note: 「ポリモーフィズム」という言葉は「多様な形」という意味であり、プログラミングにおいては同じ名前のメソッド/関数/演算子が多くのオブジェクトやクラスで実行可能であることを指します。
異なるオブジェクトで使用できるPython関数の例としては、len() 関数があります。
len() は文字列の文字数を返します：
x = "Hello World!"
print(len(x))
len() はタプル内のアイテム数を返します：
mytuple = ("apple", "banana", "cherry")
print(len(mytuple))
len() は辞書内のキー/値ペア数を返します：
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(len(thisdict))
ポリモーフィズムはクラスのメソッドでよく使用され、複数のクラスで同じメソッド名を持つことができます。
異なるクラスで同じメソッドを持つ場合：
class Car:
def __init__(self, brand, model):
self.brand = brand
self.model = model
def move(self):
print("Drive!")
class Boat:
def __init__(self, brand, model):
self.brand = brand
self.model = model
def move(self):
print("Sail!")
class Plane:
def __init__(self, brand, model):
self.brand = brand
self.model = model
def move(self):
print("Fly!")
car1 = Car("Ford", "Mustang") # Car クラスのインスタンスを作成
boat1 = Boat("Ibiza", "Touring 20") # Boat クラスのインスタンスを作成
plane1 = Plane("Boeing", "747") # Plane クラスのインスタンスを作成
for x in (car1, boat1, plane1):
x.move()
上記の最後のforループを見てください。ポリモーフィズムのおかげで、すべてのクラスで同じメソッドを実行することができます。
親クラス名が同じ子クラスを持つクラスでポリモーフィズムを使用できるでしょうか？
答えは「YES」です。上記の例を使用して、親クラスとしてVehicleというクラスを作成し、Car、Boat、PlaneをVehicleクラスの子クラスにすれば、子クラスはVehicleのメソッドを継承しますが、オーバーライドすることもできます：
Vehicleというクラスを作成し、Car、Boat、PlaneをVehicleクラスの子クラスにします：
class Vehicle:
def __init__(self, brand, model):
self.brand = brand
self.model = model
def move(self):
print("Move!")
class Car(Vehicle):
pass
class Boat(Vehicle):
def move(self):
print("Sail!")
class Plane(Vehicle):
def move(self):
print("Fly!")
car1 = Car("Ford", "Mustang") # Car オブジェクトを作成
boat1 = Boat("Ibiza", "Touring 20") # Boat オブジェクトを作成
plane1 = Plane("Boeing", "747") # Plane オブジェクトを作成
for x in (car1, boat1, plane1):
print(x.brand)
print(x.model)
x.move()
上記の例では、Carクラスは空ですが、Vehicleからbrand、model、move()を継承しています。
BoatとPlaneクラスもVehicleからbrand、model、move()を継承していますが、move()メソッドをオーバーライドしています。
ポリモーフィズムのおかげで、すべてのクラスで同じメソッドを実行することができます。
Note: イテレータは数えられる値を含むオブジェクトです。
イテレータは、順次アクセス可能なオブジェクトであり、すべての値をトラバースできます。
技術的には、Pythonでは、イテレータはイテレータプロトコルを実装したオブジェクトであり、そのメソッドに __iter__() と __next__() が含まれます。
リスト、タプル、辞書、セットはすべてイテラブルオブジェクトです。これらはイテレータを取得できるイテラブルコンテナです。
これらのオブジェクトはすべて、イテレータを取得するために使用される iter() メソッドを持っています：
mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)
print(next(myit))
print(next(myit))
print(next(myit))
文字列もイテラブルオブジェクトであり、イテレータを返すことができます：
mystr = "banana"
myit = iter(mystr)
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
forループを使用してイテラブルオブジェクトをイテレートすることもできます：
mytuple = ("apple", "banana", "cherry")
for x in mytuple:
print(x)
mystr = "banana"
for x in mystr:
print(x)
forループは実際にはイテレータオブジェクトを作成し、各ループごとに next() メソッドを実行します。
イテレータとしてオブジェクト/クラスを作成するには、オブジェクトに __iter__() と __next__() メソッドを実装する必要があります。
Pythonのクラス/オブジェクトの章で学んだように、すべてのクラスには __init__() 関数があり、オブジェクトが作成されるときに初期化を行うことができます。
__iter__() メソッドは似たような動作をしますが、操作（初期化など）を行うことができますが、常にイテレータオブジェクト自体を返さなければなりません。
__next__() メソッドも操作を行うことができ、シーケンス内の次のアイテムを返さなければなりません。
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
x = self.a
self.a += 1
return x
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
上記の例は、十分な next() 文があれば永遠に続くでしょう。
無限に続くことを防ぐために、StopIteration 文を使用することができます。
__next__() メソッドで、指定された回数のイテレーションが終了した場合にエラーを発生させる終了条件を追加することができます：
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
print(x)
Note: 継承を使うことで、他のクラスからすべてのメソッドとプロパティを継承するクラスを定義することができます。
継承を使うことで、他のクラスからすべてのメソッドとプロパティを継承するクラスを定義することができます。
親クラスは継承元のクラスであり、ベースクラスとも呼ばれます。
子クラスは他のクラスから継承されるクラスであり、派生クラスとも呼ばれます。
どんなクラスでも親クラスになれるため、構文は他のクラスを作成する場合と同じです：
class Person:
def __init__(self, fname, lname):
self.firstname = fname
self.lastname = lname
def printname(self):
print(self.firstname, self.lastname)
Person クラスを使用してオブジェクトを作成し、その後 printname メソッドを実行します：
他のクラスから機能を継承するクラスを作成するには、子クラスを作成するときに親クラスをパラメータとして渡します：
class Student(Person):
pass
Note: クラスに他のプロパティやメソッドを追加したくない場合は、pass キーワードを使用します。
これで Student クラスは Person クラスと同じプロパティとメソッドを持ちます。
x = Student("Mike", "Olsen")
x.printname()
これまでに親からプロパティやメソッドを継承する子クラスを作成しました。
子クラスに親の __init__() 関数を追加したいと考えています（pass キーワードではなく）。
Note: __init__() 関数は、新しいオブジェクトを作成するたびに自動的に呼び出されます。
class Student(Person):
def __init__(self, fname, lname):
# プロパティなどを追加します。
親の __init__() 関数の継承を保持したい場合は、親の __init__() 関数を呼び出します：
class Student(Person):
def __init__(self, fname, lname):
Person.__init__(self, fname, lname)
これで __init__() 関数が追加され、親クラスの継承が成功し、__init__() 関数の機能拡張に備える準備が整いました。
Pythonには super() 関数もあり、子クラスが親からすべてのメソッドとプロパティを継承するようにします：
class Student(Person):
def __init__(self, fname, lname):
super().__init__(fname, lname)
super() 関数を使用すると、親要素の名前を使用する必要はなく、自動的にメソッドとプロパティを継承します。
次に、Student クラスに graduationyear というプロパティを追加します：
class Student(Person):
def __init__(self, fname, lname):
super().__init__(fname, lname)
self.graduationyear = 2019
次の例では、年を表す2019は変数として、Student クラスを作成するときに渡されるべきです。これを行うには、__init__() 関数に別のパラメータを追加します：
class Student(Person):
def __init__(self, fname, lname, year):
super().__init__(fname, lname)
self.graduationyear = year
x = Student("Mike", "Olsen", 2019)
Student クラスに welcome というメソッドを追加します：
class Student(Person):
def __init__(self, fname, lname, year):
super().__init__(fname, lname)
self.graduationyear = year
def welcome(self):
print("Welcome", self.firstname, self.lastname, "to the class of", self.graduationyear)
子クラスで親クラスの関数と同じ名前のメソッドを追加すると、親メソッドの継承が上書きされます。
Note: Pythonはオブジェクト指向プログラミング言語です。
目次
Pythonではほとんどすべてがオブジェクトであり、それぞれがプロパティとメソッドを持っています。
クラスはオブジェクトのコンストラクタのようなものであり、「オブジェクトを作成するための設計図」です。
クラスを作成するには、キーワード class を使用します：
class MyClass:
x = 5
今度は、MyClass というクラスを使用してオブジェクトを作成できます：
p1 = MyClass()
print(p1.x)
上記の例はクラスとオブジェクトの基本的な形であり、実際のアプリケーションではあまり役立ちません。
クラスの意味を理解するには、組み込みの __init__() 関数を理解する必要があります。
すべてのクラスには、クラスが初期化されるときに常に実行される __init__() 関数があります。
__init__() 関数を使用して、オブジェクトのプロパティに値を割り当てたり、オブジェクトが作成されるときに必要なその他の操作を行います：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
p1 = Person("John", 36)
print(p1.name)
print(p1.age)
Note: __init__() 関数は、クラスが新しいオブジェクトを作成するたびに自動的に呼び出されます。
__str__() 関数は、クラスオブジェクトが文字列として表現されるときに返す内容を制御します。
__str__() 関数が設定されていない場合、オブジェクトの文字列表現が返されます：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
p1 = Person("John", 36)
print(p1)
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return f"{self.name}({self.age})"
p1 = Person("John", 36)
print(p1)
オブジェクトはメソッドを含むこともできます。オブジェクト内のメソッドは、オブジェクトに属する関数です。
次に、Person クラスにメソッドを作成します：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def myfunc(self):
print("Hello my name is " + self.name)
p1 = Person("John", 36)
p1.myfunc()
Note: self パラメータは、クラスの現在のインスタンスへの参照であり、クラスに属する変数にアクセスするために使用されます。
self パラメータはクラスの現在のインスタンスへの参照であり、クラスに属する変数にアクセスするために使用されます。
これは self という名前でなくても構いませんが、クラス内のすべての関数の最初のパラメータである必要があります：
class Person:
def __init__(mysillyobject, name, age):
mysillyobject.name = name
mysillyobject.age = age
def myfunc(abc):
print("Hello my name is " + abc.name)
p1 = Person("John", 36)
p1.myfunc()
次のようにしてオブジェクトのプロパティを変更できます：
p1.age = 40
del キーワードを使用してオブジェクトのプロパティを削除できます：
del p1.age
del キーワードを使用してオブジェクトを削除できます：
del p1
クラス定義は空にすることはできませんが、何らかの理由で内容のないクラス定義がある場合は、エラーを避けるために pass ステートメントを挿入します。
class Person:
pass
Note: Pythonには組み込みの配列サポートがありませんが、代わりにPythonのリストを使用することができます。
Note: このページではリストを配列として使用する方法を示していますが、Pythonで配列を操作するには、NumPyライブラリのようなライブラリをインポートする必要があります。
配列は、単一の変数に複数の値を格納するために使用されます：
cars = ["Ford", "Volvo", "BMW"]
配列は、一度に複数の値を保持できる特別な変数です。
アイテムのリスト（例えば、車の名前のリスト）がある場合、車を単一の変数に格納する場合は次のようになります：
car1 = "Ford"
car2 = "Volvo"
car3 = "BMW"
しかし、車をループして特定の車を見つけたり、3台ではなく300台の車がある場合はどうでしょうか？
その解決策が配列です！
配列は単一の名前で多くの値を保持でき、インデックス番号を参照して値にアクセスできます。
インデックス番号を使用して配列要素にアクセスします。
x = cars[0]
cars[0] = "Toyota"
len()メソッドを使用して配列の長さ（配列内の要素数）を返します。
x = len(cars)
Note: 配列の長さは常に最高の配列インデックスより1つ多いです。
for in ループを使用して配列のすべての要素をループ処理できます。
for x in cars:
print(x)
append()メソッドを使用して要素を配列に追加できます。
cars.append("Honda")
pop()メソッドを使用して配列から要素を削除できます。
cars.pop(1)
また、remove()メソッドを使用して配列から要素を削除することもできます。
cars.remove("Volvo")
Note: リストのremove()メソッドは、指定された値の最初の出現箇所のみを削除します。
Pythonには、リスト/配列で使用できる一連の組み込みメソッドがあります。
| メソッド | 説明 |
|---|---|
| append() | リストの末尾に要素を追加します |
| clear() | リストからすべての要素を削除します |
| copy() | リストのコピーを返します |
| count() | 指定された値の要素数を返します |
| extend() | リストの末尾にリスト（または任意の反復可能オブジェクト）の要素を追加します |
| index() | 指定された値を持つ最初の要素のインデックスを返します |
| insert() | 指定された位置に要素を挿入します |
| pop() | 指定された位置の要素を削除します |
| remove() | 指定された値を持つ最初の要素を削除します |
| reverse() | リストの順序を反転します |
| sort() | リストをソートします |
Note: Pythonには組み込みの配列サポートがありませんが、代わりにPythonのリストを使用することができます。
ラムダ関数は、小さな匿名関数です。
ラムダ関数は任意の数の引数を取ることができますが、式は1つだけです。
lambda 引数 : 式
式が実行され、その結果が返されます。
x = lambda a : a + 10
print(x(5))
ラムダ関数は任意の数の引数を取ることができます。
x = lambda a, b : a * b
print(x(5, 6))
x = lambda a, b, c : a + b + c
print(x(5, 6, 2))
ラムダの真の力は、別の関数の中で匿名関数として使用するときによく示されます。
もし、1つの引数を受け取る関数定義があり、その引数が未知の数値と乗算される場合：
def myfunc(n):
return lambda a : a * n
その関数定義を使用して、送信される数値を常に2倍にする関数を作成します：
def myfunc(n):
return lambda a : a * n
mydoubler = myfunc(2)
print(mydoubler(11))
または、同じ関数定義を使用して、送信される数値を常に3倍にする関数を作成します：
def myfunc(n):
return lambda a : a * n
mytripler = myfunc(3)
print(mytripler(11))
また、同じ関数定義を使用して、両方の関数を同じプログラム内に作成します：
def myfunc(n):
return lambda a : a * n
mydoubler = myfunc(2)
mytripler = myfunc(3)
print(mydoubler(11))
print(mytripler(11))
ラムダ関数は、匿名関数が一時的に必要な場合に使用します。
目次
関数は、呼び出された時にのみ実行されるコードブロックです。
パラメータとして知られるデータを関数に渡すことができます。
関数は結果としてデータを返すことができます。
Pythonでは、関数はdefキーワードを使用して定義されます:
def my_function():
print("関数からこんにちは")
関数を呼び出すには、関数名の後に括弧を付けます:
def my_function():
print("関数からこんにちは")
my_function()
情報は引数として関数に渡すことができます。
引数は、関数名の後ろに括弧の中に指定します。カンマで区切って複数の引数を追加することができます。
次の例では、1つの引数（fname）を持つ関数があります。この関数が呼び出されるときに、最初の名前を渡し、関数内でフルネームを出力します:
def my_function(fname):
print(fname + " Refsnes")
my_function("Emil")
my_function("Tobias")
my_function("Linus")
引数はPythonのドキュメントでしばしばargsとして短縮されます。
パラメータと引数という用語は同じものを指します：関数に渡される情報。
関数の観点から：
パラメータは、関数の定義の括弧の内側にリストされる変数です。
引数は、関数が呼び出されるときに送信される値です。
デフォルトでは、関数は正しい数の引数で呼び出す必要があります。つまり、関数が2つの引数を期待している場合、2つの引数で関数を呼び出す必要があります。
def my_function(fname, lname):
print(fname + " " + lname)
my_function("Emil", "Refsnes")
関数を1つまたは3つの引数で呼び出そうとするとエラーが発生します：
def my_function(fname, lname):
print(fname + " " + lname)
my_function("Emil")
関数に渡される引数の数がわからない場合は、関数定義内のパラメータ名の前に*を追加します。
このようにして、関数は引数のタプルを受け取り、それに応じてアイテムにアクセスすることができます：
def my_function(*kids):
print("最年少の子供は " + kids[2])
my_function("Emil", "Tobias", "Linus")
Pythonのドキュメントでは、任意の引数はしばしば*argsとして短縮されます。
キー = 値の構文で引数を送信することもできます。
この方法では、引数の順序は重要ではありません。
def my_function(child3, child2, child1):
print("最年少の子供は " + child3)
my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")
キーワード引数というフレーズはPythonのドキュメントではしばしばkwargsとして短縮されます。
関数に渡されるキーワード引数の数がわからない場合は、関数定義内のパラメータ名の前に2つのアスタリスク**を追加します。
この方法で関数は引数の辞書を受け取り、それに応じてアイテムにアクセスすることができます：
def my_function(**kid):
print("彼の姓は " + kid["lname"])
my_function(fname = "Tobias", lname = "Refsnes")
Pythonのドキュメントでは、任意のキーワード引数はしばしば**kwargsとして短縮されます。
次の例は、デフォルトパラメータ値の使用方法を示しています。
引数なしで関数を呼び出すと、デフォルト値が使用されます：
def my_function(country = "Norway"):
print("私は " + country + " 出身です")
my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")
任意のデータ型の引数を関数に送信することができます（文字列、数値、リスト、辞書など）。関数に到達すると、それは同じデータ型として扱われます。
たとえば、リストを引数として送信すると、関数に到達するときもリストのままです：
def my_function(food):
for x in food:
print(x)
fruits = ["apple", "banana", "cherry"]
my_function(fruits)
関数が値を返すようにするには、return文を使用します：
def my_function(x):
return 5 * x
print(my_function(3))
print(my_function(5))
print(my_function(9))
関数定義には空にすることはできませんが、何らかの理由で内容のない関数定義がある場合は、エラーを避けるためにpass文を入れてください。
def myfunction():
pass
関数に位置引数のみを持つことを指定することができます。または、キーワード引数のみを持つことを指定することもできます。
位置引数のみを指定するには、引数の後ろに , / を追加します：
def my_function(x, /):
print(x)
my_function(3)
, / を追加しないと、関数が位置引数を期待していても、実際にはキーワード引数を使用できます：
def my_function(x):
print(x)
my_function(x = 3)
, / を追加すると、キーワード引数を送信しようとするとエラーが発生します：
def my_function(x, /):
print(x)
my_function(x = 3)
関数がキーワード引数のみを受け入れることを指定するには、引数の前に*を追加します：
def my_function(*, x):
print(x)
my_function(x = 3)
*, を追加しないと、関数がキーワード引数を期待している場合でも、実際には位置引数を使用することができます：
def my_function(x):
print(x)
my_function(3)
*, / を追加すると、位置引数を送信しようとするとエラーが発生します：
def my_function(*, x):
print(x)
my_function(3)
同じ関数内でこれら2つの引数タイプを組み合わせることができます。
/の前にある任意の引数は位置引数のみであり、*の後にある任意の引数はキーワード引数のみです。
def my_function(a, b, /, *, c, d):
print(a + b + c + d)
my_function(5, 6, c = 7, d = 8)
Pythonは関数の再帰を受け入れることもできます。これは、定義された関数が自分自身を呼び出すことを意味します。
再帰は一般的な数学的およびプログラミングの概念です。これは、関数が自分自身を呼び出すことを意味します。これにより、データをループして結果に到達することができます。
開発者は、再帰は終了しない関数や、過剰なメモリやプロセッサパワーを使用する関数を書き込むのが比較的簡単であるため、非常に注意する必要があります。ただし、正しく書かれている場合、再帰は非常に効率的で数学的にエレガントなプログラミングアプローチとなります。
この例では、tri_recursion()は再帰的に呼び出す関数です。我々はk変数をデータとして使用し、それが0より大きい場合は（つまりそれが0でない場合）、再帰するたびに減少します。
再帰は、その条件が0より大きくない（つまり0である）場合に終了します。
新しい開発者にとっては、これが正確にどのように機能するかを理解するのに時間がかかる場合があります。これをテストして変更するのが最良の方法です。
def tri_recursion(k):
if(k > 0):
result = k + tri_recursion(k - 1)
print(result)
else:
result = 0
return result
print("\n\n再帰例の結果")
tri_recursion(6)