Python入門！68種類の全組み込み関数を完全解説

はじめに

Pythonは、Web開発、データ分析、AI開発といった様々な場面で使われる人気のプログラミング言語です。

その人気の理由として、Pythonが読みやすく、書きやすいシンプルな文法を持っている点が挙げられます。

また、組み込み関数と呼ばれる便利な機能も豊富に備わっており、これらをうまく使うことで効率的なプログラミングが可能になります。

●Pythonとは

Pythonは、独特のシンタックスと豊富なライブラリが特徴の高水準言語です。

ソフトウェア開発者やデータサイエンティストなど、幅広い分野で用いられています。

また、Pythonはオープンソースであるため、誰でも無料で利用できます。

○Pythonの特徴

Pythonの特徴は、次の通りです。

①シンプルで読みやすい文法

Pythonの文法は、他のプログラミング言語と比べてシンプルであり、コードの可読性が高いとされています。

これにより、コードの理解やデバッグが容易になります。

②豊富なライブラリ

Pythonは、数値計算、データ解析、機械学習などのための豊富なライブラリを持っています。

これにより、特定の目的に合わせたプログラミングが可能です。

③ポータビリティ

Pythonはクロスプラットフォームであり、Windows、Mac、Linuxなど、異なるOSで動作します。

④オープンソース

Pythonはオープンソースであるため、誰でも自由に使用、改変、配布することができます。

●Pythonの組み込み関数とは

Pythonの組み込み関数とは、Pythonがデフォルトで提供している関数のことを指します。

これらの関数は特別なインポートなどを必要とせず、いつでもどこでも利用可能です。

○組み込み関数の種類

Pythonの組み込み関数は多数あり、その中には数値を扱うための関数、文字列を扱うための関数、リストや辞書などのデータ構造を扱うための関数など、さまざまな種類の関数が含まれています。

それぞれの関数がどのような操作を行い、どのような場合に使用されるのかを理解することで、より効率的なプログラミングが可能になります。

●Python組み込み関数68選

それでは、Pythonの組み込み関数のうち、特によく使われる68の関数を見ていきましょう。

各関数について、その基本的な使い方や応用例をサンプルコードとともに紹介します。

○関数1：abs

Pythonのabs関数は、引数として与えられた数値の絶対値を返す関数です。

□使い方とサンプルコード

num = -10
print(abs(num))

上記のコードでは、abs関数を使って変数numの絶対値を計算しています。

この例では、numの値は-10なので、abs(num)の結果は10となります。

つまり、print(abs(num))は10を出力します。

□応用例とサンプルコード

abs関数は、数値計算だけでなく、ベクトルの長さを計算する際にも使用できます。

例えば、2次元のベクトル（x, y）の長さは、sqrt(x^2 + y^2)で計算できますが、これはabs関数を使って表現することができます。

import math
x, y = 3, 4
length = math.sqrt(x**2 + y**2)
print(length)

このコードでは、sqrt関数を使ってベクトルの長さを計算しています。

この例では、x=3、y=4なので、lengthの値は5.0となります。

つまり、print(length)は5.0を出力します。

このようにabs関数は、数値やベクトルの絶対値を求める際に役立ちます。

○関数2：all

Pythonのall関数は、引数として与えられたイテラブル（リストやタプルなど）のすべての要素が真であるかどうかをチェックする関数です。

□使い方とサンプルコード

list = [True, True, False]
print(all(list))

上記のコードでは、all関数を使ってリストの全ての要素が真であるかをチェックしています。

この例では、リストの一つの要素がFalseなので、all(list)の結果はFalseとなります。

つまり、print(all(list))はFalseを出力します。

□応用例とサンプルコード

all関数は、すべての要素が特定の条件を満たしているかを確認するのに便利です。

例えば、リストのすべての要素が正の数であるかどうかを確認するには、次のように書くことができます。

num_list = [1, 2, 3, -1, 5]
print(all(num > 0 for num in num_list))

このコードでは、リストの各要素（num）が正の数（num > 0）であるかどうかをall関数でチェックしています。

この例では、一つの要素が負の数なので、all(num > 0 for num in num_list)の結果はFalseとなります。

つまり、print(all(num > 0 for num in num_list))はFalseを出力します。

このように、all関数は条件を満たす要素が全てかどうかを確認する際に便利です。

○関数3：any

Pythonのany関数は、引数として与えられたイテラブル（リストやタプルなど）の中に真の値が一つでもあるかを判断する関数です。

□使い方とサンプルコード

下記のサンプルコードは、リストの中に真の値があるかを判定するものです。

リストの中にはTrueとFalseが混じっており、any関数によってその中にTrueが一つでもあるかどうかが判断されます。

list = [True, False, False]
print(any(list))

このコードでは、any関数を使ってリストの中に真の値が存在するかを確認しています。

この例では、リストにはTrueが1つ含まれているので、any(list)の結果はTrueとなります。

したがって、print(any(list))はTrueを出力します。

□応用例とサンプルコード

any関数は、要素の中に特定の条件を満たすものが一つでもあるかを確認するのに便利です。

例えば、リストの中に負の数が一つでも含まれているかを確認する場合は、次のように書くことができます。

num_list = [1, 2, 3, -1, 5]
print(any(num < 0 for num in num_list))

このコードでは、リストの各要素（num）が負の数（num < 0）であるかどうかをany関数でチェックしています。

この例では、リストの中に-1という負の数が含まれているため、any(num < 0 for num in num_list)の結果はTrueとなります。

したがって、print(any(num < 0 for num in num_list))はTrueを出力します。

以上、any関数についての基本的な使い方と応用例を紹介しました。

Pythonプログラミングにおいて、特定の条件を満たす要素が存在するかどうかを判定する際に、any関数は非常に有用です。

この関数を理解し活用することで、より簡潔かつ効率的なプログラミングが可能となります。

○関数4：ascii

Pythonのascii関数は、オブジェクトを表す文字列を生成する関数です。

ただし、非ASCII文字はエスケープされます。

つまり、英字や数字、一部の記号などはそのまま表示されますが、それ以外の文字（日本語や特殊記号など）はエスケープシーケンスで表示されます。

□使い方とサンプルコード

下記のサンプルコードでは、ascii関数を使って日本語の文字列をエスケープシーケンスで表示します。

print(ascii("こんにちはPython"))

このコードでは、ascii関数を使って”こんにちはPython”という文字列をエスケープシーケンスに変換しています。

この例では、英語の”Python”はそのまま表示されますが、日本語の”こんにちは”はエスケープシーケンスに変換されて表示されます。

その結果、print(ascii(“こんにちはPython”))は’\u3053\u3093\u306b\u3061\u306fPython’を出力します。

□応用例とサンプルコード

ascii関数は、非ASCII文字を含む文字列を扱う際に有用です。

例えば、ユーザー入力の安全性を確認する際に使用することができます。

user_input = "こんにちはPython"
safe_input = ascii(user_input)
print(safe_input)

このコードでは、ユーザーから入力された文字列（この例では”こんにちはPython”）をascii関数で安全な形に変換しています。

その結果、print(safe_input)は’\u3053\u3093\u306b\u3061\u306fPython’を出力します。

これにより、悪意のあるユーザーがスクリプト注入を試みても、ascii関数によって非ASCII文字がエスケープされ、システムに対する攻撃を防ぐことができます。

○関数5：bin

Pythonのbin関数は、整数を引数として受け取り、その2進数表現を文字列として返す関数です。

主にデバッグや計算の中間結果の確認に使われます。

□使い方とサンプルコード

下記のサンプルコードでは、bin関数を使って整数を2進数に変換するコードを紹介しています。

この例では整数10を2進数に変換しています。

print(bin(10))

このコードを実行すると、「0b1010」という出力が得られます。

ここで「0b」は2進数であることを示すプレフィクスで、その後ろに続く「1010」が10の2進数表現です。

□応用例とサンプルコード

bin関数は、ビット演算を扱う際に特に有用です。

下記のサンプルコードでは、2つの整数のビットAND演算の結果を2進数で表示する例を紹介します。

num1 = 12
num2 = 10

# ビットAND演算
result = num1 & num2

print("ビットANDの結果:", bin(result))

このコードでは、まず2つの整数num1とnum2に対してビットAND演算を行い、その結果をresultに代入しています。

そして、bin関数を使ってresultを2進数に変換し、その結果を表示しています。

このコードを実行すると、「ビットANDの結果: 0b1000」という出力が得られます。

これは12と10のビットANDの結果が8（2進数で1000）であることを示しています。

以上が、Pythonのbin関数についての基本的な使い方と応用例です。

この関数を理解し活用することで、整数の2進数表現を容易に取得したり、ビット演算の結果を直感的に理解することができます。

○関数6：bool

Pythonには、データが真偽値であるかどうかを判定するための組み込み関数boolが存在します。

このbool関数は引数に指定されたオブジェクトが真偽値であるかを判定し、その結果を返します。

□使い方とサンプルコード

bool関数の基本的な使い方は非常に簡単で、bool関数の引数に対象となるオブジェクトを指定するだけです。

下記のサンプルコードでは、数値0と文字列”Hello”がbool関数によってどのように評価されるかを見てみましょう。

# サンプルコード
print(bool(0))  # 出力結果: False
print(bool("Hello"))  # 出力結果: True

このコードでは、最初に数値の0をbool関数の引数として与えています。Pythonでは数値の0は偽（False）として評価されます。

次に、空でない文字列”Hello”をbool関数の引数として与えています。Pythonでは空でない文字列は真（True）として評価されます。

したがって、このコードを実行すると、最初のprint関数ではFalseが、次のprint関数ではTrueが出力されます。

□応用例とサンプルコード

bool関数は、if文などの条件判断で真偽値が必要な場合に使用することができます。

下記のサンプルコードでは、リストが空でない場合にメッセージを表示する処理を実装しています。

# サンプルコード
my_list = [1, 2, 3]
if bool(my_list):
    print("リストは空ではありません。")

このコードでは、最初に[1, 2, 3]という要素を持つリストmy_listを定義しています。

次に、if文を用いてmy_listが空でない場合（つまり、my_listをbool関数で評価した結果がTrueの場合）に、”リストは空ではありません。”というメッセージを出力しています。

したがって、このコードを実行すると、my_listが空でないため、”リストは空ではありません。”というメッセージが出力されます。

○関数7：bytearray

Pythonには非常に便利なデータ型が揃っています。

その中の一つがbytearray型です。

bytearray型は、バイト列を扱うための組み込み関数で、byte型と違い可変（変更可能）な特性を持っています。

□使い方とサンプルコード

bytearray関数の基本的な使い方を見ていきましょう。

下記のサンプルコードは、文字列をbytearray型に変換する一例です。

# 文字列をbytearray型に変換
byte_array = bytearray("Python入門", "utf-8")
print(byte_array)

このコードでは、”Python入門”という文字列をbytearray関数を使ってbytearray型に変換しています。

第二引数の”utf-8″は文字列のエンコーディングを指定しています。

実行結果は次のようになります。

# 実行結果
bytearray(b'Python\xe5\x85\xa5\xe9\x96\x80')

□応用例とサンプルコード

bytearray型の魅力はその可変性にあります。

下記のサンプルコードでは、一度bytearray型に変換した後、要素を変更しています。

# bytearray型の要素を変更
byte_array = bytearray("Python入門", "utf-8")
byte_array[0] = 74  # ASCIIコードで'J'に対応する数値
print(byte_array)

このコードでは、まずbytearray関数を使って文字列をbytearray型に変換し、その後インデックスを指定して要素を変更しています。

ここでは0番目の要素（’P’）をASCIIコードで’J’に対応する数値（74）に置き換えています。

実行結果は次のようになります。

# 実行結果
bytearray(b'Jython\xe5\x85\xa5\xe9\x96\x80')

ご覧の通り、元の’Python入門’という文字列の’P’が’J’に置き換わっています。

bytearray型を使えば、バイト列の要素を直接操作することが可能となるのです。

このようにbytearray型は、データのバイナリ操作やネットワーク通信に関するプログラミングなどで活躍する便利なデータ型です。

○関数8：bytes

Pythonの組み込み関数であるbytesは、immutable（変更不能）なバイト列を作成します。

この関数は非常に便利で、主にバイナリデータを扱う際に使用されます。

しかし、初心者にとっては少々扱いが難しいかもしれません。この記事では、その使い方と応用例をわかりやすく解説します。

□使い方とサンプルコード

まずは基本的な使い方から始めましょう。

bytes関数は主に次のように使用されます。

# 空のバイト列を作成する
empty_bytes = bytes()
print(empty_bytes)

# 整数のシーケンスからバイト列を作成する
seq_bytes = bytes([65, 66, 67])
print(seq_bytes)

# 文字列をエンコードしてバイト列を作成する
str_bytes = bytes('ABC', 'utf-8')
print(str_bytes)

このコードでは、まず空のバイト列を作成しています。

次に、整数のシーケンスからバイト列を作成しています。

ここでは、整数のリスト[65, 66, 67]が与えられ、それぞれの整数は対応するASCII文字を表します。

最後に、文字列’ABC’をUTF-8形式でエンコードし、バイト列を作成しています。

このコードを実行すると、次のような結果が得られます。

b''
b'ABC'
b'ABC'

□応用例とサンプルコード

それでは次に、bytes関数を応用したサンプルコードを見てみましょう。

このサンプルコードでは、画像ファイルをバイト列として読み込んで、それを新しいファイルとして書き出す処理を行います。

# 画像ファイルをバイト列として読み込む
with open('input.jpg', 'rb') as f:
    data = f.read()

# バイト列を新しいファイルとして書き出す
with open('output.jpg', 'wb') as f:
    f.write(data)

このコードでは、まずinput.jpgという画像ファイルをバイナリモードで開いて、その内容をバイト列として読み込んでいます。

次に、そのバイト列を新しいoutput.jpgというファイルに書き出しています。

このように、bytes関数はファイルのバイナリデータを扱う際に非常に便利です。

なお、このコードを実行すると、input.jpgの内容がoutput.jpgに正確にコピーされます。

このように、bytes関数はバイナリデータの扱いを容易にするため、Pythonでファイルのコピーなど、様々な場面で使用されます。

○関数9：callable

Pythonの組み込み関数であるcallableは、与えられたオブジェクトが「呼び出し可能」かどうかを判定します。

つまり、そのオブジェクトが関数のように呼び出せる（()を使って実行できる）かどうかをチェックします。

関数やクラス、メソッドなどは呼び出し可能なオブジェクトです。

□使い方とサンプルコード

まずは基本的な使い方から見ていきましょう。

callable関数は次のように使用されます。

# 関数を定義
def my_func():
    return

# 関数が呼び出し可能かどうかをチェック
result = callable(my_func)
print(result)

このコードでは、まずmy_funcという関数を定義しています。

次に、この関数が呼び出し可能かどうかをcallable関数でチェックしています。

このコードを実行すると、次のような結果が得られます。

True

つまり、my_funcは呼び出し可能な関数であることが確認できました。

□応用例とサンプルコード

それでは次に、callable関数の応用例を見てみましょう。

このサンプルコードでは、与えられたオブジェクトが関数かどうかをチェックし、関数であればその結果を表示し、そうでなければエラーメッセージを表示する関数を定義します。

def run_func(func):
    if callable(func):
        result = func()
        print(f'結果: {result}')
    else:
        print('エラー: 引数は関数でなければなりません。')

# 呼び出し可能な関数を引数に渡す
run_func(my_func)

# 呼び出し不可能な整数を引数に渡す
run_func(123)

このコードでは、run_funcという関数を定義しています。

この関数は引数としてfuncを受け取り、そのfuncが呼び出し可能かどうかをcallable関数でチェックしています。

もしfuncが呼び出し可能であれば、その関数を実行し、その結果を表示します。

もしfuncが呼び出し不可能であれば、エラーメッセージを表示します。

このコードを実行すると、次のような結果が得られます。

結果: None
エラー: 引数は関数でなければなりません。

つまり、my_funcは呼び出し可能な関数であり、その結果が表示されました。

一方、整数123は呼び出し不可能なので、エラーメッセージが表示されました。

このように、callable関数はPythonで関数のエラーハンドリングを行う際に非常に有用です。

○関数10：chr

Pythonの組み込み関数であるchrは、整数をUnicode文字に変換します。

つまり、指定したUnicodeのコードポイントに対応する文字を取得します。

Unicodeは世界中のほぼすべての文字を表現するための工業規格で、PythonではこのUnicodeを使って文字を扱います。

□使い方とサンプルコード

まずは基本的な使い方から見ていきましょう。

chr関数は次のように使用されます。

# Unicodeのコードポイントを文字に変換
char = chr(65)
print(char)

このコードでは、Unicodeのコードポイント65を文字に変換しています。

コードポイント65はASCIIで言うところの大文字の’A’に対応しています。

このコードを実行すると、次のような結果が得られます。

A

つまり、コードポイント65は文字の’A’に変換されました。

□応用例とサンプルコード

それでは次に、chr関数の応用例を見てみましょう。

このサンプルコードでは、指定した範囲のコードポイントをすべて文字に変換し、それを表示します。

# 指定した範囲のコードポイントを文字に変換
for i in range(65, 70):
    print(chr(i))

このコードでは、for文を使って65から69までの整数（コードポイント）をすべて文字に変換し、それを表示しています。

このコードを実行すると、次のような結果が得られます。

A
B
C
D
E

つまり、コードポイント65から69はそれぞれ文字の’A’から’E’に変換されました。

このように、chr関数はコードポイントと文字の間で変換を行う際に非常に便利です。

○関数11：classmethod

クラスメソッドとは、その名の通りクラスに属しているメソッドのことを指します。

Pythonの組み込み関数であるclassmethodは、通常のメソッドをクラスメソッドに変換するものです。

classmethodが使われると、そのメソッドはクラスオブジェクトを第一引数として受け取ります。

つまり、インスタンスオブジェクトではなくクラスオブジェクトを操作することができます。

□使い方とサンプルコード

ここでは、Pythonでのclassmethodの基本的な使い方とサンプルコードを見てみましょう。

class MyClass:
    count = 0

    @classmethod
    def increment(cls):
        cls.count += 1
        print(f'カウント: {cls.count}')

MyClass.increment()
MyClass.increment()

このコードでは、まずMyClassという名前のクラスを定義しています。

このクラスには、クラス変数countとクラスメソッドincrementがあります。

incrementメソッドは、classmethodデコレータを使って定義されており、このメソッドはクラスオブジェクトを引数に取ります。

incrementメソッドが呼び出されると、count変数の値が1増え、その値が表示されます。

このコードを実行すると、次のような結果が得られます。

カウント: 1
カウント: 2

この結果からわかるように、incrementメソッドが呼び出されるたびに、クラス変数countの値が1増えています。

□応用例とサンプルコード

次に、クラスメソッドを活用したサンプルコードを見てみましょう。

class MyCounter:
    _count = 0

    @classmethod
    def increment(cls):
        cls._count += 1
        return cls._count

print(MyCounter.increment())
print(MyCounter.increment())

このコードでは、MyCounterというクラスを定義しています。

このクラスには、クラス変数_countとクラスメソッドincrementが定義されています。

incrementメソッドは、呼び出されるたびに_countの値を1増やし、その値を返します。

このコードを実行すると、次のような結果が得られます。

1
2

このように、クラスメソッドはクラスレベルでの状態管理に非常に便利です。

また、クラスメソッドはインスタンス化しなくても

クラスから直接呼び出すことが可能なため、必要に応じて使い分けることができます。

○関数12：compile

Pythonの組み込み関数compileは、Pythonのソースコードをバイトコードに変換します。

バイトコードとは、Pythonのインタプリタが理解できる低レベルのコードです。

compile関数は主に動的に生成されたPythonコードを実行するために使用されます。

□使い方とサンプルコード

compile関数の基本的な使い方とサンプルコードを紹介します。

source_code = """
for i in range(3):
    print(f'ループ回数: {i+1}')
"""
compiled_code = compile(source_code, '<string>', 'exec')
exec(compiled_code)

このコードでは、まずsource_codeという名前の変数にPythonのソースコードを文字列として代入しています。

次に、このソースコードをcompile関数に渡してバイトコードに変換し、その結果をcompiled_codeという変数に代入しています。

最後に、exec関数を使用してバイトコードを実行しています。

このコードを実行すると、次のような結果が得られます。

ループ回数: 1
ループ回数: 2
ループ回数: 3

このように、ソースコードがバイトコードに変換され、そのバイトコードが実行されるという流れになります。

□応用例とサンプルコード

次に、compile関数の応用例を見てみましょう。

def compile_and_run(source_code):
    compiled_code = compile(source_code, '<string>', 'exec')
    exec(compiled_code)

source_code = """
for i in range(3):
    print(f'ループ回数: {i+1}')
"""
compile_and_run(source_code)

このコードでは、先程のコードを関数化しています。

compile_and_run関数は、ソースコードを引数に取り、そのソースコードをバイトコードに変換し、そのバイトコードを実行します。

このコードを実行すると、次のような結果が得られます。

ループ回数: 1
ループ回数: 2
ループ回数: 3

このように、compile関数は動的に生成されたPythonのソースコードを実行する際に非常に便利です。

○関数13：complex

Pythonの組み込み関数であるcomplexは、複素数を生成するための関数です。

複素数とは、実数と虚数からなる数のことを指します。

Pythonでは、虚数はjまたはJを使って表現されます。

□使い方とサンプルコード

complex関数の基本的な使い方とサンプルコードを紹介します。

c1 = complex(2, 3)
print(c1)

c2 = complex(1)
print(c2)

c3 = complex()
print(c3)

このコードでは、まずcomplex関数を使って実数部が2、虚数部が3の複素数を生成し、その結果をc1という変数に代入しています。

次に、complex関数を使って実数部が1、虚数部が0の複素数を生成し、その結果をc2という変数に代入しています。

最後に、complex関数を引数なしで呼び出し、その結果をc3という変数に代入しています。

このコードを実行すると、次のような結果が得られます。

(2+3j)
(1+0j)
0j

このように、complex関数を使って様々な複素数を生成することができます。

□応用例とサンプルコード

次に、complex関数の応用例を見てみましょう。

c1 = complex(2, 3)
c2 = complex(1, 1)
c3 = c1 + c2
print(c3)

このコードでは、まずcomplex関数を使って2つの複素数c1とc2を生成しています。

そして、これらの複素数を加算し、その結果をc3という変数に代入しています。

このコードを実行すると、次のような結果が得られます。

(3+4j)

このように、complex関数を使って生成した複素数は、通常の数値と同様に加算などの算術演算を行うことができます。

○関数14：delattr

delattrはPythonの組み込み関数で、指定したオブジェクトから指定した属性を削除する役割があります。

この関数は、プログラムの実行中に動的に属性を削除したい場合に役立ちます。

□使い方とサンプルコード

delattr関数を使用するときの一般的な方法は、第一引数にオブジェクトを、第二引数に削除する属性の名前を指定するというものです。

class SampleClass:
    attr1 = "attr1 value"
    attr2 = "attr2 value"

# オブジェクトを生成
obj = SampleClass()
print(obj.attr1)  # attr1 value
print(obj.attr2)  # attr2 value

# attr2を削除
delattr(SampleClass, "attr2")
print(obj.attr1)  # attr1 value
print(obj.attr2)  # AttributeError: 'SampleClass' object has no attribute 'attr2'

このコードでは、最初にSampleClassというクラスを定義しており、このクラスにはattr1とattr2という2つの属性があります。

オブジェクトobjを作成後、delattr関数を使用してattr2を削除しています。その結果、obj.attr2を呼び出すとエラーが発生します。

これはattr2が存在しないからです。

□応用例とサンプルコード

次に、delattr関数の応用例として、属性の存在を確認してから削除する方法を紹介します。

class SampleClass:
    attr1 = "attr1 value"
    attr2 = "attr2 value"

# オブジェクトを生成
obj = SampleClass()

# attr2が存在するか確認してから削除
if hasattr(SampleClass, "attr2"):
    delattr(SampleClass, "attr2")

print(obj.attr1)  # attr1 value
try:
    print(obj.attr2)
except AttributeError:
    print("attr2は存在しません。")  # attr2は存在しません。

このコードでは、delattrを使用する前にhasattrを用いてattr2が存在するかどうかを確認しています。

これにより、存在しない属性を削除しようとしてエラーが発生することを防ぐことができます。

○関数15：dict

dict関数は、新しい辞書を作成するためのPythonの組み込み関数です。

辞書はキーと値のペアを保持するデータ構造であり、頻繁に使用されるPythonの基本データ型の一つです。

□使い方とサンプルコード

下記のコードは、dict関数を用いて新しい辞書を作成する一般的な方法を示しています。

#キーと値のペアからなる辞書を作成
dict1 = dict(apple=1, banana=2, cherry=3)
print(dict1)  # {'apple': 1, 'banana': 2, 'cherry': 3}

# キーワード引数無しで辞書を作成（空の辞書）
dict2 = dict()
print(dict2)  # {}

このコードでは、dict関数を使用して2つの辞書を作成しています。

dict1はキーワード引数を用いて辞書を作成しており、各キーワードが辞書のキーとなり、その値が辞書の値となっています。

一方、dict2は引数を与えずに作成しています。そのため、空の辞書が作成されます。

□応用例とサンプルコード

次に、タプルのリストを用いて辞書を作成する方法を紹介します。

# タプルのリストから辞書を作成
list_of_tuples = [('apple', 1), ('banana', 2), ('cherry', 3)]
dict_from_tuples = dict(list_of_tuples)
print(dict_from_tuples)  # {'apple': 1, 'banana': 2, 'cherry': 3}

このコードでは、タプルのリストを引数にdict関数を使用しています。

各タプルの最初の要素が辞書のキーとなり、2番目の要素が対応する値となっています。

○関数16：dir

dir関数はPythonの組み込み関数で、指定したオブジェクトが持っている属性やメソッドの一覧を取得することができます。

特に引数を指定しない場合は、現在のローカルスコープの名前をリストとして返します。

□使い方とサンプルコード

下記のコードは、dir関数の基本的な使い方を表しています。

class SampleClass:
    attr1 = "attr1 value"
    def method1(self):
        pass

# オブジェクトを生成
obj = SampleClass()

# objが持つ属性とメソッドを取得
print(dir(obj))

このコードでは、まずSampleClassというクラスを定義し、その中にattr1という属性とmethod1というメソッドを持つオブジェクトobjを作成しています。

そして、dir関数を使用してobjが持つ属性とメソッドの一覧を取得しています。

□応用例とサンプルコード

次に、引数を指定せずに現在のローカルスコープの名前を取得する方法を示します。

x = 1
y = 2
z = 3

# 現在のローカルスコープの名前

を取得
local_scope = dir()
print(local_scope)

このコードでは、まずx、y、zという3つの変数を定義しています。

その後、dir関数を引数無しで呼び出すことで、現在のローカルスコープに存在する名前の一覧を取得しています。

○関数17：divmod

divmodはPythonの組み込み関数で、2つの数値の商と余りを同時に計算します。

引数として2つの数値を取り、商と余りをタプルとして返します。

□使い方とサンプルコード

下記のコードは、divmod関数を使用して商と余りを求める一般的な方法を表しています。

# 7を3で割った時の商と余りを計算
quotient, remainder = divmod(7, 3)
print(quotient)  # 2
print(remainder)  # 1

このコードでは、divmod関数を使用して7を3で割ったときの商と余りを計算しています。

計算結果はタプルとして返されるため、その値をquotientとremainderに分けて受け取っています。

□応用例とサンプルコード

次に、divmod関数を使用して時間の計算を行う方法を紹介します。

# 秒数を時間、分、秒に分ける
seconds = 3661
hours, remainder = divmod(seconds, 3600)
minutes, seconds = divmod(remainder, 60)
print(hours)  # 1
print(minutes)  # 1
print(seconds)  # 1

このコードでは、まず3661秒という時間を持っています。

この秒数を時間、分、秒に分けて表示するために、まずdivmod関数を使用して秒数を3600で割り、時間と余りの秒数を計算しています。

その後、余りの秒数を60で割ることで分と秒を計算しています。

○関数18：enumerate

enumerate関数はPythonの組み込み関数で、列挙可能なオブジェクト（リストやタプルなど）を引数として取り、インデックスと値をタプルとして返すイテレータを作成します。

□使い方とサンプルコード

下記のコードは、enumerate関数を使用してリストの各要素とそのインデックスを同時に取得する方法を表しています。

fruits = ["apple", "banana", "cherry"]

# enumerate関数を使用してインデックスと値を取得
for i, fruit in enumerate(fruits):
    print(f"Index: {i}, Value: {fruit}")

このコードでは、まずリストfruitsを定義しています。

その後、enumerate関数を使用してfruitsの各要素とそのインデックスを同時に取得しています。

そして、取得したインデックスと値をそれぞれ出力しています。

このコードを実行すると、次のような結果が得られます。

Index: 0, Value: apple
Index: 1, Value: banana
Index: 2, Value: cherry

□応用例とサンプルコード

enumerate関数は、リスト内の特定の値のインデックスを検索する際にも役立ちます。

次のコードでは、リスト内の特定の値を探し、そのインデックスを出力する方法を示しています。

fruits = ["apple", "banana", "cherry", "banana"]

# "banana"のインデックスを取得
indexes = [i for i, fruit in enumerate(fruits) if fruit == "banana"]
print(indexes)  # [1, 3]

このコードでは、まずフルーツのリストを定義し、その中には”banana”が2つ含まれています。

次にリスト内包表記とenumerate関数を組み合わせて、”banana”が存在するインデックスを全て取得しています。

このコードを実行すると、”banana”が存在するインデックスのリスト[1, 3]が出力されます。

○関数19：eval

eval関数は、Pythonの組み込み関数で、文字列形式のPython式を評価して結果を返します。

□使い方とサンプルコード

下記のコードは、eval関数を使用して文字列形式のPython式を評価する基本的な方法を表しています。

expression = "1 + 2 * 3"
result = eval(expression)
print(result)  # 7

このコードでは、まず文字列形式のPython式”1 + 2 * 3″を定義しています。

その後、eval関数を使用してこの式を評価し、結果を出力しています。

このコードを実行すると、Pythonの演算子優先度に従って式が評価され、結果として7が出力されます。

□応用例とサンプルコード

eval関数は、動的にPythonコードを生成して実行する場合に便利です。

しかし、ユーザーからの入力をそのまま評価すると、意図しないコードが実行される可能性があるため、使用には注意が必要です。

次のコードでは、辞書内の値を動的に取得する方法を表しています。

data = {'apple': 1, 'banana': 2, 'cherry': 3}
key = 'banana'
expression = f"data['{key}']"
result = eval(expression)
print(result)  # 2

このコードでは、まず辞書とキーを定義しています。

そして、キーを使って辞書から値を取得するPython式を文字列として作成します。

次に、eval関数を使用してこの式を評価し、結果を出力しています。

このコードを実行すると、キー’banana’に対応する値2が出力されます。

○関数20：exec

exec関数は、Pythonの組み込み関数で、文字列形式のPythonのプログラムを実行します。

eval関数とは異なり、exec関数は式ではなくステートメント（命令）を実行します。

□使い方とサンプルコード

下記のコードは、exec関数を使用して文字列形式のPythonのプログラムを実行する基本的な方法を表しています。

program = """
x = 10
y = 20
print(x + y)  # 30
"""
exec(program)

このコードでは、まず変数xとyを定義し、その和を出力するPythonのプログラムを文字列として定義しています。

その後、exec関数を使用してこのプログラムを実行しています。

このコードを実行すると、変数xとyの和である30が出力されます。

□応用例とサンプルコード

exec関数は、動的にPythonコードを生成して実行する場合に便利です。

しかし、ユーザーからの入力をそのまま実行すると、意図しないコードが実行される可能性があるため、使用には注意が必要です。

次のコードでは、動的にforループを生成して実行する方法を表しています。

n = 5
program = f"""
for i in range({n}):
    print(i)
"""
exec(program)

このコードでは、まず変数nを定義しています。

その後、このnを使ってforループを含むPythonのプログラムを文字列として作成しています。

最後に、exec関数を使用してこのプログラムを実行しています。

このコードを実行すると、0からn-1までの数値が順番に出力されます。

○関数21：filter

filter関数は、与えられた関数を使ってシーケンス（リスト、タプルなど）から特定の要素をフィルタリングするための関数です。

□使い方とサンプルコード

基本的な使い方を下記のコードでご確認いただけます。

def is_even(n):
    return n % 2 == 0

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtered_numbers = filter(is_even, numbers)

print(list(filtered_numbers))  # [2, 4, 6, 8, 10]

このコードでは、まず偶数を判定する関数is_evenを定義しています。

そして、1から10までの整数を含むリストnumbersを作成し、filter関数を使ってこのリストから偶数だけを取り出しています。

最後に、結果を出力しています。

このコードを実行すると、リストnumbersから偶数のみが取り出され、[2, 4, 6, 8, 10]と出力されます。

□応用例とサンプルコード

filter関数は、より複雑な条件で要素をフィルタリングするのにも使えます。

下記のコードでは、文字列のリストから特定の文字を含む要素だけを取り出す方法を示しています。

def contains_s(s):
    return 's' in s

words = ['apple', 'banana', 'cherry', 'grapes', 'lemon', 'strawberry']
filtered_words = filter(contains_s, words)

print(list(filtered_words))  # ['grapes', 'strawberry']

このコードでは、まず特定の文字（ここでは’s’）を含むかどうかを判定する関数contains_sを定義しています。

そして、いくつかのフルーツの名前を含むリストwordsを作成し、filter関数を使ってこのリストから’s’を含む要素だけを取り出しています。

最後に、結果を出力しています。

このコードを実行すると、リストwordsから’s’を含む要素だけが取り出され、['grapes', 'strawberry']と出力されます。

○関数22：float

float関数は、数値または文字列を浮動小数点数に変換するための関数です。

□使い方とサンプルコード

基本的な使い方を下記のコードでご確認いただけます。

num1 = 10
num2 = float(num1)

print(num2)  # 10.0

str

_num = '20.5'
num3 = float(str_num)

print(num3)  # 20.5

このコードでは、まず整数の10を変数num1に代入しています。

次に、float関数を使ってこの整数を浮動小数点数に変換し、結果をnum2に代入しています。

同様に、文字列の’20.5’を浮動小数点数に変換し、結果をnum3に代入しています。

最後に、それぞれの結果を出力しています。

このコードを実行すると、num2は10.0と出力され、num3は20.5と出力されます。

□応用例とサンプルコード

float関数は、ユーザーからの入力を数値に変換するのにも使えます。

下記のコードは、ユーザーからの入力を浮動小数点数に変換し、それを2倍する例です。

user_input = input("数値を入力してください: ")
num = float(user_input)
double_num = num * 2

print("2倍した値は", double_num, "です。")

このコードを実行し、例えば5.5と入力すると、「2倍した値は 11.0 です。」と出力されます。

○関数23：format

format関数は、指定されたフォーマットに従って値を整形するための関数です。

□使い方とサンプルコード

基本的な使い方を下記のコードでご確認いただけます。

num = 1234.5678
formatted_num = format(num, '.2f')

print(formatted_num)  # '1234.57'

このコードでは、まず浮動小数点数1234.5678を変数numに代入しています。

次に、format関数を使ってこの数値を小数点以下2位までの浮動小数点数として整形し、結果をformatted_numに代入しています。

最後に、結果を出力しています。

このコードを実行すると、formatted_numは’1234.57’と出力されます。

□応用例とサンプルコード

format関数は、様々なフォーマットの文字列を作成するのにも使えます。

下記のコードは、文字列内で変数の値を整形して出力する例です。

name = "John"
age = 20
greeting = "Hello, {}. You are {} years old."

formatted_greeting = greeting.format(name, age)

print(formatted_greeting)  # 'Hello, John. You are 20 years old.'

このコードでは、まず名前と年齢をそれぞれ変数nameとageに代入しています。

そして、出力したい挨拶文を変数greetingに代入しています。

次に、format関数を使って挨拶文中の{}に対して、nameとageの値を代入し、結果をformatted_greetingに代入しています。

最後に、整形した挨拶文を出力しています。

このコードを実行すると、formatted_greetingは’Hello, John. You are 20 years old.’と出力されます。

○関数24：frozenset

frozenset関数は、変更不可能な集合を作成するための関数です。

一度作成したfrozensetは、その後のプログラムの中で変更することはできません。

□使い方とサンプルコード

基本的な使い方を下記のコードでご確認いただけます。

numbers = [1, 2, 2, 3, 4, 4, 4, 5]
frozen_numbers = frozenset(numbers)

print(frozen_numbers)  # frozenset({1, 2, 3, 4, 5})

このコードでは、まず重複した数字を含むリストを変数numbersに代入しています。

次に、frozenset関数を使ってこのリストからfrozensetを作成し、結果をfrozen_numbersに代入しています。

最後に、frozensetの中身を出力しています。

このコードを実行すると、frozen_numbersはfrozenset({1, 2, 3, 4, 5})と出力されます。

これは、重複した数字が除去され、順序も保証されない集合を表現しています。

□応用例とサンプルコード

frozensetは、辞書のキーとして使うこともできます。

下記のコードは、frozensetを辞書のキーとして使用する例です。

numbers1 = frozenset([1, 2, 3])
numbers2 = frozenset([4, 5, 6])
dict_numbers = {numbers1: "123", numbers2: "456"}

print(dict_numbers)  # {frozenset({1, 2, 3}): '123', frozenset({4, 5, 6}): '456'}

このコードでは、まず2つのfrozensetを作成し、それぞれを変数numbers1とnumbers2に代入しています。

次に、これらのfrozensetをキーとする辞書を作成し、それをdict_numbersに代入しています。最後に、辞書の中身を出力しています。

このコードを実行すると、dict_numbersは{frozenset({1, 2, 3}): ‘123’, frozenset({4, 5, 6}): ‘456’}と出力されます。

○関数25：getattr

Pythonでオブジェクトの属性を動的に取得したいときに便利なのが「getattr」関数です。

指定した名前の属性が存在すればその値を返し、存在しない場合はデフォルト値を返します。

□使い方とサンプルコード

基本的な使い方を下記のコードで確認できます。

class Sample:
    def __init__(self):
        self.x = 10
        self.y = 20

sample = Sample()
print(getattr(sample, 'x'))  # 10
print(getattr(sample, 'z', 30))  # 30

このコードでは、まずSampleというクラスを定義し、その中に属性xとyを持たせています。

次にSampleクラスのインスタンスを作成し、それをsampleという変数に代入しています。

その後、getattr関数を使ってsampleオブジェクトの属性xの値を取得しています。

同様に、存在しない属性zの値を取得しようとしていますが、デフォルト値として30を指定しているので30が出力されます。

このコードを実行すると、最初のprint文では10が、次のprint文では30が出力されます。

□応用例とサンプルコード

次に、getattrを使って動的にメソッドを呼び出す例を見てみましょう。

class Sample:
    def hello(self):
        return 'Hello, Python!'

sample = Sample()
method_name = 'hello'
method = getattr(sample, method_name)

if method:
    print(method())  # 'Hello, Python!'

このコードでは、Sampleというクラスを定義し、その中にhelloというメソッドを持たせています。

次にSampleクラスのインスタンスを作成し、それをsampleという変数に代入しています。

そして、文字列method_nameにメソッド名’hello’を代入し、getattr関数を使ってそのメソッドを取得しています。

取得したメソッドが存在すれば、そのメソッドを呼び出して結果を出力します。

このコードを実行すると、’Hello, Python!’という文字列が出力されます。

○関数26：globals

globals関数は、現在のグローバルシンボルテーブルを表す辞書を返す関数です。

この辞書は常に現在のモジュールに対するもので、この辞書に変更を加えると、実際のモジュールの中身が変更されます。

□使い方とサンプルコード

基本的な使い方を下記のコードで確認できます。

x = 10
y = 20
print(globals())  # {'__name__': '__main__', 'x': 10, 'y': 20, ...}

このコードでは、まずグローバル変数xとyを定義し、その後でglobals関数を呼び出しています。

この関数はグローバルシンボルテーブルを表す辞書を返すので、出力結果にはxとyの名前と値が含まれています。

このコードを実行すると、辞書形式でグローバル変数の名前と値が表示されます。

ただし、この辞書には他にも様々な要素が含まれています。

具体的には、Pythonが内部で使用している特殊な名前（__name__など）や、インポートしたモジュールなどの情報も含まれています。

□応用例とサンプルコード

globals関数は、動的な名前の変数を作成したい場合などに便利です。

for i in range(3):
    globals()['var{}'.format(i)] = i
print(var0, var1, var2)  # 0 1 2

このコードでは、まずforループを使って0から2までの範囲を順に処理しています。

ループ内でglobals関数を呼び出し、辞書へ新たなエントリを追加しています。

このエントリのキーは'var{}'.format(i)によって生成された文字列（var0、var1、var2）で、値はループのカウンター（i）です。

最後に、作成した変数をprint関数で出力しています。

このコードを実行すると、0 1 2という結果が出力されます。

これは、var0、var1、var2という名前の変数が作成され、それぞれに0、1、2という値が設定されているからです。

○関数27：hasattr

hasattr関数は、指定したオブジェクトが特定の属性を持っているかどうかを調べるための関数です。

属性が存在すればTrueを、存在しなければFalseを返します。

□使い方とサンプルコード

基本的な使い方を下記のコードで確認できます。

class Sample:
    def __init__(self):
        self.x = 10

sample = Sample()
print(hasattr(sample, 'x'))  # True
print

(hasattr(sample, 'y'))  # False

このコードでは、まずSampleという名前のクラスを定義しています。

このクラスの中で、インスタンス変数xを初期化しています。

次に、Sampleクラスのインスタンスを作成し、そのインスタンスがxという名前の属性を持っているかどうかをhasattr関数で確認しています。

結果はTrueです。

一方、yという名前の属性は存在しないので、その結果はFalseになります。

□応用例とサンプルコード

hasattr関数は、オブジェクトが特定のメソッドを持っているかどうかを確認するのにも使えます。

class Sample:
    def foo(self):
        pass

sample = Sample()
print(hasattr(sample, 'foo'))  # True
print(hasattr(sample, 'bar'))  # False

このコードでは、まずSampleクラスを定義しています。

このクラスにはfooというメソッドが定義されています。

次に、このクラスのインスタンスを作成し、そのインスタンスがfooというメソッドを持っているかどうかをhasattr関数で確認しています。

結果はTrueになります。

一方、barというメソッドは定義されていないので、その結果はFalseになります。

○関数28：hash

hash関数は、Pythonのハッシュ可能なオブジェクト（数値、文字列、タプルなど）からハッシュ値を取得するための関数です。

このハッシュ値は、オブジェクトの内容が同じであれば同じ値を返す一方、内容が異なれば異なる値を返すことが期待されます。

□使い方とサンプルコード

下記のコードでは、数値、文字列、タプルに対してhash関数を適用しています。

数値に対するhash関数の結果は、その数値自体となります。

文字列やタプルのハッシュ値は、その内容に基づいた一貫した値ですが、具体的な値はPythonのバージョンや環境により異なる可能性があります。

print(hash(10))  # 10
print(hash('Hello'))  # 8315274433719620810 (例)
print(hash((1, 2, 3)))  # 2528502973977326415 (例)

□応用例とサンプルコード

hash関数は、辞書のキーや集合の要素として使用するオブジェクトがハッシュ可能であるかどうかを確認する際に役立ちます。

例えば、下記のコードでは、タプルとリストに対してhash関数を適用しています。

print(hash((1, 2, 3)))  # 2528502973977326415 (例)
print(hash([1, 2, 3]))  # TypeError: unhashable type: 'list'

タプルはハッシュ可能なので、hash関数を適用できます。

一方、リストはハッシュ不可能なので、hash関数を適用しようとするとTypeErrorが発生します。

○関数29：help

help関数は、Pythonオブジェクト（関数、モジュール、クラスなど）のドキュメンテーション（説明）を表示するための関数です。

ドキュメンテーションは、そのオブジェクトの使い方や機能を理解するのに役立ちます。

□使い方とサンプルコード

下記のコードでは、print関数のドキュメンテーションを表示しています。

この例では、help関数を使ってprint関数の説明を取得しています。

help(print)

これを実行すると、print関数の説明が表示されます。

この説明には、関数の概要、引数の説明、使用例などが含まれています。

しかし、このコードの実行結果をここに表すことはできません。

なぜなら、出力は非常に長くなり、また実行環境やPythonのバージョンによって異なる可能性があるからです。

□応用例とサンプルコード

Pythonの標準ライブラリやサードパーティのモジュールについてもhelp関数を使用することができます。

下記のコードでは、mathモジュールのドキュメンテーションを表示しています。

import math
help(math)

これを実行すると、mathモジュールの全体的な説明や、モジュール内の関数とクラスのリストが表示されます。

各関数やクラスの具体的な説明を見るには、その名前をhelp関数の引数に指定します。

○関数30：hex

hex関数は、整数を16進数表記の文字列に変換するための関数です。

この関数は、「0x」を先頭に付けた16進数表記の文字列を返します。

□使い方とサンプルコード

以下のコードでは、数値10と255を16進数に変換しています。

この例では、hex関数を使ってこれらの数値を16進数表記の文字列に変換しています。

print(hex(10))  # '0xa'
print(hex(255))  # '0xff'

このコードを実行すると、数値10は16進数では’a’、255は’ff’になるため、結果はそれぞれ’0xa’と’0xff’となります。

□応用例とサンプルコード

hex関数は、バイナリデータのデバッグや、色のRGB値をHTML形式に変換する際などに使用できます。

例えば、下記のコードでは、RGB値をHTML形式に変換しています。

def rgb_to_html(r, g, b):
    return '#' + hex(r)[2:].zfill(2) + hex(g)[2:].zfill(2) + hex(b)[2:].zfill(2)

print(rgb_to_html(255, 0, 128))  # '#ff0080'

このコードでは、RGB値を表す3つの数値を受け取り、それぞれを16進数に変換した後、2文字になるように前に0を付け足して（zfillメソッドを使って）、’#’を前に付けてHTML形式に変換しています。

○関数31：id

Pythonのid関数は、指定したオブジェクトの「識別番号」（メモリ上のアドレス）を取得する関数です。

この識別番号は、オブジェクトが存在する限り一意で不変であり、オブジェクトの「同一性」を確認するのに使われます。

□使い方とサンプルコード

下記のコードは、数値と文字列、リストのオブジェクトに対してid関数を使用しています。

この例では、それぞれのオブジェクトの識別番号を取得しています。

num = 100
str_ = 'Python'
list_ = [1, 2, 3]

print(id(num))  # 出力例：139861011486608
print(id(str_))  # 出力例：139861072097904
print(id(list_))  # 出力例：139861071909120

このコードを実行すると、それぞれのオブジェクトの識別番号が表示されます。

ただし、これらの数値はシステムによって異なります。

□応用例とサンプルコード

オブジェクトの同一性を確認する際にid関数を使用します。

下記のコードは、リストをコピーし、元のリストとコピーしたリストが同一のものであるかどうかを確認する例です。

list1 = [1, 2, 3]
list2 = list1  # list1の参照をコピー
list3 = list1.copy()  # list1の要素を新たなリストにコピー

print(id(list1) == id(list2))  # True
print(id(list1) == id(list3))  # False

このコードを実行すると、list1とlist2が同じ識別番号を持つため、最初の比較結果はTrueになります。

一方、list1とlist3は異なる識別番号を持つため、2つ目の比較結果はFalseになります。

これは、list3が新たに作られた別のオブジェクトであることを示しています。

○関数32：input

input関数は、ユーザーからの入力を受け取る関数です。

この関数はキーボードからの入力を文字列として返します。

□使い方とサンプルコード

下記のコードでは、ユーザーに名前を入力してもらい、その名前を表示しています。

name = input("あなたの名前を入力してください：")
print("あなたの名前は " + name + " です。")

このコードを実行すると、まず”あなたの名前を入力してください：”と表示され、ユーザーの入力を待ちます。

ユーザーが名前を入力してEnterキーを押すと、その名前が取得されて表示されます。

□応用例とサンプルコード

input関数は、インタラクティブなスクリプトを作成する際によく使用されます。

下記のコードは、ユーザーに2つの数値を入力してもらい、その合計を計算する例です。

num1 = int(input("最初の数字を入力してください："))
num2 = int(input("次の数字を入力してください："))
print("合計は " + str(num1 + num2) + " です。")

このコードを実行すると、まず最初の数値の入力を求め、次に2つ目の数値の入力を求めます。

ユーザーがそれぞれの数値を入力してEnterキーを押すと、それらの数値がint関数によって整数に変換され、合計が計算されて表示されます。

○関数33：int

int関数は、数値または文字列を整数に変換する関数です。

この関数は、基数（進数）を指定することもできます。

□使い方とサンプルコード

下記のコードは、浮動小数点数と文字列を整数に変換しています。

print(int(3.14))  # 3
print(int('100'))  # 100

このコードを実行すると、浮動小数点数の3.14は整数の3に、文字列の’100’は整数の100に変換されます。

□応用例とサンプルコード

int関数の応用例として、異なる基数で表された数値の変換があります。

下記のコードは、2進数と16進数の文字列を整数に変換する例です。

print(int('1010', 2))  # 10
print(int('A', 16))  # 10

このコードを実行すると、2進数の’1010’と16進数の’A’がそれぞれ10に変換されます。

これは、int関数が第二引数として基数を取れるためで、その基数に基づいて第一引数の文字列を整数に変換します。

○関数34：isinstance

isinstance関数は、指定したオブジェクトが指定した型または型のタプルのいずれかに属するかどうかを調べる関数です。

この関数は、型判定を行う際によく使われます。

□使い方とサンプルコード

下記のコードは、整数、文字列、リストがそれぞれint型、str型、list型に属するかどうかを判定しています。

num = 100
str_ = 'Python'
list_ = [1, 2, 3]

print(isinstance(num, int))  # True
print(isinstance(str_, str))  # True
print(isinstance(list_, list))  # True

このコードを実行すると、それぞれのオブジェクトが所属する型に対してisinstance関数を適用したので、すべての結果がTrueになります。

□応用例とサンプルコード

isinstance関数は、複数の型を同時にチェックすることもできます。

下記のコードは、数値がint型またはfloat型に属するかどうかを判定する例です。

num1 = 100
num2 = 3.14

print(isinstance(num1, (int, float)))  # True
print(isinstance(num2, (int, float)))  # True

このコードを実行すると、num1とnum2がいずれもint型またはfloat型に属しているため、結果はTrueになります。

○関数35：issubclass

issubclass関数は、指定したクラスが指定したクラスのサブクラスであるかどうかを調べるための関数です。

□使い方とサンプルコード

ここでは、自分で定義したクラスが組み込みのlistクラスのサブクラスであるかどうかを調べるコードを紹介します。

class MyClass(list):
    pass

print(issubclass(MyClass, list))  # True

このコードでは、listクラスを継承してMyClassという新しいクラスを定義しています。

その後、issubclass関数を使用してMyClassがlistクラスのサブクラスであるかどうかをチェックしています。

結果として、MyClassはlistクラスのサブクラスであるため、Trueが出力されます。

□応用例とサンプルコード

issubclass関数は、複数のクラスを同時にチェックすることもできます。

自作のクラスが組み込みのlistクラスとstrクラスのサブクラスであるかどうかを調べる例を紹介します。

class MyClass(list):
    pass

print(issubclass(MyClass, (list, str)))  # True

このコードでは、最初にlistクラスを継承して新しいクラスを作成しています。

そして、issubclass関数を使用して、MyClassがlistクラスまたはstrクラスのサブクラスであるかどうかをチェックしています。

結果として、MyClassはlistクラスのサブクラスであるため、Trueが出力されます。

しかし、MyClassはstrクラスのサブクラスではないので、もしlistとstrの両方のサブクラスであることをチェックすると、結果はFalseになるでしょう。

○関数36：iter

iter関数は、オブジェクトからイテレータを取得するための関数です。

イテレータは、要素を一つずつ取り出すことができるオブジェクトで、for文で使用できます。

□使い方とサンプルコード

ここでは、リストからイテレータを取得し、その要素を順に取り出すコードを紹介します。

my_list = [1, 2, 3]
my_iter = iter(my_list)

print(next(my_iter))  # 1
print(next(my_iter))  # 2
print(next(my_iter))  # 3

このコードでは、まずリストを定義し、その後iter関数を使用してリストからイテレータを取得しています。

そして、next関数を使用してイテレータから要素を一つずつ取り出しています。出力結果として、リストの要素が順に表示されます。

□応用例とサンプルコード

iter関数は、2つの引数を取ることもできます。第一引数は呼び出される無引数関数、第二引数は終了値となります。

ここでは、ランダムな数を生成し、特定の値が生成されるまで続けるコードを示します。

import random

random_iter = iter(lambda: random.randint(0, 5), 2)

for num in random_iter:
    print(num)

このコードでは、無引数関数として0から5までのランダムな数を生成するlambda関数を定義し、終了値として2を指定しています。

そして、for文を使ってイテレータから数値を取り出しています。

このプロセスは、ランダムに生成された数が2になると停止します。

したがって、出力は0から5までのランダムな数列で、2が出現するまで続きます。

○関数37：len

Pythonの組み込み関数であるlen関数は、オブジェクト（リスト、文字列、タプルなど）の要素数を取得するために使用します。

□使い方とサンプルコード

len関数の使い方は簡単で、関数の引数に要素数を調べたいオブジェクトを指定します。

例えば、リストの要素数を取得する場合のコードは次のようになります。

my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print(length)  # 5

このコードでは、my_listというリストを定義し、len関数を使ってその要素数を取得しています。

そしてその結果を表示しています。

この例ではリストに5つの要素があるため、出力結果は5になります。

□応用例とサンプルコード

len関数は、文字列の長さを取得する場合にも使えます。

次のコードでは、文字列の長さを取得しています。

my_str = 'Python'
length = len(my_str)
print(length)  # 6

このコードでは、my_strという文字列を定義し、len関数を使ってその長さを取得しています。そしてその結果を表示しています。

この例では文字列’Python’は6文字からなるため、出力結果は6になります。

○関数38：list

Pythonの組み込み関数であるlist関数は、異なるデータ型をリストに変換するために使用します。

たとえば、タプルや文字列をリストに変換することができます。

□使い方とサンプルコード

list関数の基本的な使い方を見ていきましょう。

次のコードでは、タプルをリストに変換しています。

my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)  # [1, 2, 3]

このコードでは、my_tupleというタプルを定義し、list関数を使ってタプルをリストに変換しています。

そしてその結果を表示しています。

この例では、タプル(1, 2, 3)がリスト[1, 2, 3]に変換されています。

□応用例とサンプルコード

list関数は、文字列をリストに変換する場合にも使えます。

この場合、文字列の各文字がリストの要素となります。

次のコードでは、文字列をリストに変換しています。

my_str = 'Python'
my_list = list(my

_str)
print(my_list)  # ['P', 'y', 't', 'h', 'o', 'n']

このコードでは、my_strという文字列を定義し、list関数を使って文字列をリストに変換しています。そしてその結果を表示しています。

この例では、文字列’Python’の各文字がリストの要素となっていて、結果は[‘P’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’]となります。

○関数39：locals

locals関数はPythonの組み込み関数で、現在のローカルシンボルテーブルを表す辞書を返します。

ローカルシンボルテーブルとは、現在のスコープ内の変数や関数などの名前とその値を持つ辞書のことを指します。

□使い方とサンプルコード

次のコードでは、現在のローカルシンボルテーブルを取得して表示しています。

def sample_function():
    local_var = 123
    print(locals())

sample_function()

このコードでは、sample_functionという関数内でlocal_varというローカル変数を定義し、locals関数を使って現在のローカルシンボルテーブルを取得して表示しています。

この結果、{‘local_var’: 123}という辞書が出力されます。

□応用例とサンプルコード

locals関数は、動的に変数を作成する場合などに使うことができます。

次のコードでは、ローカルシンボルテーブルを取得し、新たに変数を作成しています。

def create_variable(name, value):
    locals()[name] = value
    print(locals())

create_variable('my_var', 456)

このコードでは、create_variableという関数内で、引数として与えられたnameとvalueを使って新たな変数を作成しています。

しかし、この方法は一般的には推奨されません。

なぜなら、関数が終了するとローカル変数は消滅するため、その変数を関数の外で使用することはできないからです。

○関数40：map

Pythonの組み込み関数であるmap関数は、特定の関数を引数として渡されたイテラブルの全ての要素に適用し、その結果を返す関数です。

□使い方とサンプルコード

次のコードでは、与えられたリストの全ての要素を2倍にするための関数をmap関数で適用しています。

def double(n):
    return n * 2

numbers = [1, 2, 3, 4, 5]
result = map(double, numbers)

print(list(result))  # [2, 4, 6, 8, 10]

このコードでは、doubleという関数を定義し、それをnumbersというリストの全ての要素に適用しています。そしてその結果を表示しています。

この例では、元のリストの全ての要素が2倍になり、結果は[2, 4, 6, 8, 10]となります。

□応用例とサンプルコード

map関数は、ラムダ関数と組み合わせて使うことも多いです。

次のコードでは、ラムダ関数を使ってリストの全ての要素を2倍にしています。

numbers = [1, 2, 3, 4, 5]
result = map(lambda n: n * 2, numbers)

print(list(result))  # [2, 4, 6, 8, 10]

このコードでは、ラムダ関数を使ってリストの全ての要素を2倍にしています。

ラムダ関数は、一時的に使う小さな関数を定義するための機能で、この例ではそれを使って全ての要素を2倍にしています。

結果は同様に[2, 4, 6, 8, 10]となります。

○関数41：max

Pythonの組み込み関数であるmax関数は、引数として与えられた値の中で最大のものを返します。

□使い方とサンプルコード

次のコードでは、与えられたリストの中で最大の要素を求めています。

numbers = [1, 2, 3, 4, 5]
max_number = max(numbers)

print(max_number)  # 5

このコードでは、numbersというリストの中で最大の要素をmax関数を使って求めています。

この例では、最大の要素は5となります。

□応用例とサンプルコード

max関数は、キーワード引数keyを使って、最大値を判定する基準を自由に設定することができます。

次のコードでは、与えられた文字列の中で最も長いものを求めています。

words = ['Python', 'Java', 'JavaScript', 'Ruby', 'Go']
longest_word = max(words, key=len)

print(longest_word)  # 'JavaScript'

このコードでは、wordsというリストの中で最も長い文字列を求めています。

max関数のkey引数にlen関数を設定することで、最大値を判定する基準としています。

この例では、最も長い文字列は’JavaScript’となります。

○関数42：memoryview

Pythonの組み込み関数であるmemoryview関数は、引数として与えられたバイト列やバイト配列などのオブジェクトをメモリビューとして扱います。

メモリビューは、データをコピーせずに扱うことができるので、大量のデータを扱う場合に効率的です。

□使い方とサンプルコード

次のコードでは、バイト配列をメモリビューとして扱い、その要素を表示しています。

byte_array = bytearray([1, 2, 3, 4, 5])
mem_view = memoryview(byte_array)

for i in mem_view:
    print(i)

このコードでは、byte_arrayというバイト配列を作成し、memoryview関数を使ってそれをメモリビューとして扱います。

そしてそのメモリビューの各要素を表示しています。

この例では、出力結果は1から5までの数字になります。

□応用例とサンプルコード

メモリビューは、データを直接操作することも可能です。

次のコードでは、メモリビューの要素を直接変更しています。

byte_array = bytearray([1, 2, 3, 4, 5])
mem_view = memoryview(byte_array)

mem_view[0] = 100
print(byte_array)  # bytearray(b'd\x02\x03\x04\x05')

このコードでは、byte_arrayというバイト配列を作成し、memoryview関数を使ってそれをメモリビューとして扱います。

そしてそのメモリビューの最初の要素を100に変更しています。

その結果、byte_arrayも同時に更新され、最初の要素が100になります。

○関数43：min

Pythonの組み込み関数であるmin関数は、引数として与えられた値の中で最小のものを返します。

□使い方とサンプルコード

次のコードでは、与えられたリストの中で最小の要素を求めています。

numbers = [1, 2, 3, 4, 5]
min_number = min(numbers)

print(min_number)  # 1

このコードでは、numbersというリストの中で最小の要素をmin関数を使って求めています。

この例では、最小の要素は1となります。

□応用例とサンプルコード

min関数もmax関数同様に、キーワード引数keyを使って、最小値を判定する基準を自由に設定することができます。

次のコードでは、与えられた文字列の中で最も短いものを求めています。

words = ['Python', 'Java', 'JavaScript', 'Ruby', 'Go']
shortest_word = min(words, key=len)

print(shortest_word)  # 'Go'

このコードでは、wordsというリストの中で最も短い文字列を求めています。

min関数のkey引数にlen関数を設定することで、最小値を判定する基準を文字列の長さに設定しています。

この例では、最も短い文字列は’Go’となります。

○関数44：next

Pythonの組み込み関数であるnext関数は、イテレータの次の要素を取得します。

□使い方とサンプルコード

次のコードでは、リストをイテレータに変換し、その次の要素を取得しています。

numbers = [1, 2, 3, 4, 5]
iter_numbers = iter(numbers)

print(next(iter_numbers))  # 1
print(next(iter_numbers))  # 2

このコードでは、numbersというリストをiter関数を使ってイテレータに変換しています。

そしてnext関数を使って、そのイテレータの次の要素を取得しています。

この例では、最初に1を取得し、次に2を取得しています。

□応用例とサンプルコード

next関数は、第2引数にデフォルト値を設定することができます。

次の要素がない場合には、そのデフォルト値が返されます。

次のコードでは、デフォルト値を設定しています。

numbers = [1, 2, 3]
iter_numbers = iter(numbers)

print(next(iter_numbers, 'No more elements'))  # 1
print(next(iter_numbers, 'No more elements'))  # 2
print(next(iter_numbers, 'No more elements'))  # 3
print(next(iter_numbers, 'No more elements'))  # 'No more elements'

このコードでは、numbersというリストをiter関数を使ってイテレータに変換し、その次の要素を取得しています。

次の要素がない場合には、’No more elements’という文字列が返されます。

この例では、最初に1、次に2、そして3を取得した後に、次の要素がないためにデフォルト値の’No more elements’が返されます。

○関数45：object

Pythonの組み込み関数であるobject関数は、新しい無属性オブジェクトを生成します。

object関数は特に引数を取らず、その結果として得られるオブジェクトは、何も属性を持たない空のオブジェクトです。

□使い方とサンプルコード

次のコードでは、新しいオブジェクトを生成し、その型を確認しています。

obj = object()

print(type(obj))  # <class 'object'>

このコードでは、object関数を用いて新しいオブジェクトを生成し、そのオブジェクトの型を表示しています。

この例では、出力結果は<class 'object'>となり、生成されたオブジェクトがobjectクラスのインスタンスであることを確認できます。

□応用例とサンプルコード

object関数で生成されるオブジェクトは属性を持たないため、基本的には特殊な目的で使用されます。

例えば、一意なマーカーとして使用することができます。

次のコードでは、object関数で生成したオブジェクトを一意なマーカーとして使用しています。

MARKER = object()

def search_in_list(lst, value, default=MARKER):
    try:
        return lst.index(value)
    except ValueError:
        if default is MARKER:
            raise
        return default

lst = [1, 2, 3, 4, 5]
print(search_in_list(lst, 3))  # 2
print(search_in_list(lst, 6, -1))  # -1

このコードでは、リストの中から指定した値を探し、そのインデックスを返す関数を定義しています。

デフォルト値としてobject関数で生成した一意のマーカーを使用し、指定した値が見つからなかったときにはそのデフォルト値を返すようにしています。

指定した値が見つからず、かつデフォルト値が設定されていない場合には例外を送出します。

○関数46：oct

oct関数はPythonの組み込み関数の一つで、整数を8進数の文字列に変換します。

□使い方とサンプルコード

次のコードは、10を8進数に変換し、その結果を出力する例です。

num = 10
oct_num = oct(num)

print(oct_num)  # '0o12'

このコードでは、まず変数numに10を代入し、その値をoct関数に渡して8進数の文字列に変換しています。

そして、その結果を出力しています。結果として’0o12’が得られます。

□応用例とサンプルコード

8進数の表現は特にファイルパーミッションの設定などUnix系のシステムでよく使用されます。

そのため、10進数のパーミッション値を8進数の文字列に変換することで、より直感的に理解しやすくなります。

permission = 755
oct_permission = oct(permission)

print(oct_permission)  # '0o1363'

このコードでは、ファイルパーミッションの値755を8進数の文字列に変換し、その結果を出力しています。

結果として’0o1363’が得られます。

○関数47：open

open関数はPythonの組み込み関数であり、ファイルを開くために使用されます。

□使い方とサンプルコード

次のコードでは、テキストファイルを読み込むためにopen関数を使用しています。

with open('example.txt', 'r') as f:
    content = f.read()

print(content)

このコードでは、’example.txt’という名前のファイルを読み込みモード(‘r’)で開いています。

そして、そのファイルの内容を全て読み込み、それを出力しています。

出力結果は開いたファイルの内容によります。

□応用例とサンプルコード

open関数を使って、テキストファイルに書き込むことも可能です。

次のコードでは、テキストファイルに文字列を書き込むためにopen関数を使用しています。

with open('example.txt', 'w') as f:
    f.write('Hello, Python!')

with open('example.txt', 'r') as f:
    content = f.read()

print(content)  # 'Hello, Python!'

このコードでは、’example.txt’という名前のファイルを書き込みモード(‘w’)で開き、’Hello, Python!’という文字列を書き込んでいます。

次に、同じファイルを読み込みモード(‘r’)で開き、その内容を読み込んで出力しています。

このとき、出力結果は先ほど書き込んだ’Hello, Python!’となります。

○関数48：ord

ord関数はPythonの組み込み関数で、文字のUnicode表現を整数として取得するために使用されます。

□使い方とサンプルコード

次のコードは、文字’a’のUnicode表現を取得して出力する例です。

char = 'a'
unicode_val = ord(char)

print(unicode_val)  # 97

このコードでは、まず変数charに’a’を代入し、そのUnicode表現をord関数により取得しています。

そして、その結果を出力しています。結果として97が得られます。

□応用例とサンプルコード

ord関数は、文字列の各文字に対するUnicode表現を取得し、それを基に特定の処理を行う際に役立ちます。

次のコードは、文字列の各文字をそのUnicode表現に変換し、それらの合計値を求める例です。

text = 'Hello, Python!'
unicode_sum = sum(ord(c) for c in text)

print(unicode_sum)  # 1244

このコードでは、’Hello, Python!’の各文字のUnicode表現を取得し、それらの合計値を求めています。結果として1244が得られます。

○関数49：pow

pow関数はPythonの組み込み関数で、べき乗の計算を行うために使用されます。

□使い方とサンプルコード

次のコードは、2の3乗を計算し、その結果を出力する例です。

result = pow(2, 3)

print(result)  # 8

このコードでは、pow関数を使って2の3乗を計算し、その結果を出力しています。

結果として8が得られます。

□応用例とサンプルコード

pow関数は3つめの引数を取ることができ、その場合にはべき乗の結果をその数で割った余りを求めます。

次のコードは、5の3乗を7で割った余りを求める例です。

result = pow(5, 3, 7)

print(result)  # 6

このコードでは、5の3乗を7で割った余りを求め、その結果を出力しています。

結果として6が得られます。

○関数50：print

print関数はPythonの組み込み関数で、引数として与えられた内容を標準出力に出力するために使用されます。

□使い方とサンプルコード

次のコードは、’Hello, Python!’という文字列を出力する例です。

print('Hello, Python!')  # Hello, Python!

このコードでは、’Hello, Python!’という文字列を出力しています。

□応用例とサンプルコード

print関数は、複数の引数を受け取ることができ、その場合には引数が空白文字で連結されて出力されます。

また、’sep’パラメータを使用して、引数を連結する際の区切り文字を指定することもできます。

print('Hello,', 'Python!', sep=' ')  # Hello, Python!

このコードでは、’Hello,’と’Python!’という2つの引数を空白文字で連結して出力しています。

○関数51：property

property関数はPythonの組み込み関数で、クラスの属性に対するゲッター、セッター、デリーターを定義するために使用されます。

□使い方とサンプルコード

次のコードは、’Person’クラスの’name’属性に対してゲッターとセッターを定義する例です。

class Person:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        self._name = value


person = Person('Alice')
print(person.name)  # Alice

person.name = 'Bob'
print(person.name)  # Bob

このコードでは、まず’Person’クラスを定義しています。

その中で、’name’属性のゲッターとセッターをproperty関数を使用して定義しています。

そして、’Person’クラスのインスタンスを作成し、その’name’属性にアクセスしています。

○関数52：range

range関数はPythonの組み込み関数で、連続する整数の範囲を生成するために使用されます。

□使い方とサンプルコード

次のコードは、0から4までの連続する整数を生成し、その結果をリストとして出力する例です。

numbers = range(5)
numbers_list = list(numbers)

print(numbers_list)  # [0, 1, 2, 3, 4]

このコードでは、range関数を使用して0から4までの連続する整数を生成しています。

そして、その結果をリストに変換して出力しています。結果として、[0, 1, 2, 3, 4]というリストが得られます。

□応用例とサンプルコード

range関数は、引数を2つまたは3つ与えることもでき、その場合にはそれぞれ開始値と終了値、開始値と終了値とステップ（増分）を指定することができます。

次のコードは、1から9までの奇数を生成し、その結果をリストとして出力する例です。

numbers = range(1, 10, 2)
numbers_list = list(numbers)

print(numbers_list)  # [1, 3, 5, 7, 9]

このコードでは、range関数を使用して1から9までの奇数を生成しています。

そして、その結果をリストに変換して出力しています。結果として、[1, 3, 5, 7, 9]というリストが得られます。

○関数53：repr

repr関数はPythonの組み込み関数で、オブジェクトの「文字列表現」を取得するために使用されます。

□使い方とサンプルコード

次のコードは、整数の10の文字列表現を取得し、その結果を出力する例です。

num = 10
repr_str = repr(num)

print(repr_str)  # '10'

このコードでは、まず変数numに10を代入し、その文字列表現をrepr関数により取得しています。

そして、その結果を出力しています。結果として、’10’が得られます。

□応用例とサンプルコード

repr関数は、リストや辞書などの複雑なデータ構造の文字列表現を取得する際にも使用できます。

次のコードは、リストの文字列表現を取得する例です。

lst = [1, 2, 3]
repr_str = repr(lst)

print(repr_str)  # '[1, 2, 3]'

このコードでは、まずリスト[1, 2, 3]を変数lstに代入し、その文字列表現をrepr関数により取得しています。

そして、その結果を出力しています。

結果として、'[1, 2, 3]’が得られます。

○関数54：reversed

reversed関数はPythonの組み込み関数で、シーケンスの要素を逆順にした新しいイテレータを作成するために使用されます。

□使い方とサンプルコード

次のコードは、リストの要素を逆順にした新しいリストを作成し、その結果を出力する例です。

numbers = [1, 2, 3, 4, 5]
reversed_numbers = list(reversed(numbers))

print(reversed_numbers)  # [5, 4, 3, 2, 1]

このコードでは、まずリスト[1, 2, 3, 4, 5]を変数numbersに代入しています。

次に、reversed関数を使用してnumbersの要素を逆順にした新しいイテレータを作成し、その結果をリストに変換しています。

そして、その結果を出力しています。

結果として、[5, 4, 3, 2, 1]というリストが得られます。

□応用例とサンプルコード

reversed関数は、文字列の文字を逆順にした新しい文字列を作成する際にも使用できます。

次のコードは、文字列の文字を逆順にした新しい文字列を作成し、その結果を出力する例です。

s = 'Python'
reversed_s = ''.join(reversed(s))

print(reversed_s)  # 'nohtyP'

このコードでは、まず文字列’Python’を変数sに代入しています。

次に、reversed関数を使用してsの文字を逆順にした新しいイテレータを作成し、その結果を”.join()メソッドで文字列に変換しています。

そして、その結果を出力しています。

結果として、’nohtyP’という文字列が得られます。

○関数55: round

round関数はPythonの組み込み関数で、浮動小数点数または数値を表す文字列を最も近い整数に丸めるために使用されます。

小数点以下の数値が0.5の場合、偶数の方に丸められます。

□使い方とサンプルコード

次のコードは、浮動小数点数3.14159を最も近い整数に丸め、その結果を出力する例です。

num = 3.14159
rounded_num = round(num)

print(rounded_num)  # 3

このコードでは、まず浮動小数点数3.14159を変数numに代入しています。

次に、round関数を使用してnumを最も近い整数に丸め、その結果を出力しています。結果として、3が得られます。

□応用例とサンプルコード

round関数は、引数を2つに与えることも可能で、その場合は指定した桁数で四捨五入します。

次のコードは、浮動小数点数3.14159を小数点以下第2位で四捨五入し、その結果を出力する例です。

num = 3.14159
rounded_num = round(num, 2)

print(rounded_num)  # 3.14

このコードでは、まず浮動小数点数3.14159を変数numに代入しています。

次に、round関数を使用してnumを小数点以下第2位で四捨五入し、その結果を出力しています。

結果として、3.14が得られます。

○関数56：set

set関数はPythonの組み込み関数で、新たなセット（集合）オブジェクトを生成するために使用されます。

セットは順序が無く、また同じ要素が2つ以上存在することはありません。

□使い方とサンプルコード

次のコードは、リストからセットを生成し、その結果を出力する例です。

numbers = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
numbers_set = set(numbers)

print(numbers_set)  # {1, 2, 3, 4, 5}

このコードでは、まずリスト[1, 1, 2, 2, 3, 3, 4, 4, 5, 5]を変数numbersに代入しています。

次に、set関数を使用してnumbersからセットを生成し、その結果を出力しています。

結果として、{1, 2, 3, 4, 5}というセットが得られます。

ここで、セットは順序が無いため、出力結果の順序は実行するたびに異なる可能性があります。

□応用例とサンプルコード

set関数は、リストなどのデータ構造から重複する要素を取り除く際にも使用できます。

次のコードは、リストから重複する要素を取り除き、その結果を出力する例です。

numbers = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
numbers_set = set(numbers)
unique_numbers = list(numbers_set)

print(unique_numbers)  # [1, 2, 3, 4, 5]

このコードでは、まずリスト[1, 1, 2, 2, 3, 3, 4, 4, 5, 5]を変数numbersに代入しています。

次に、set関数を使用してnumbersからセットを生成し、その結果をリストに変換しています。

そして、その結果を出力しています。結果として、[1, 2, 3, 4, 5]という重複要素を取り除いたリストが得られます。

○関数57：setattr

setattr関数はPythonの組み込み関数で、オブジェクトの属性を設定するために使用されます。

この関数を使うと、文字列として渡された属性名に対応する属性を設定することが可能です。

□使い方とサンプルコード

次のコードは、クラスのインスタンスの属性を設定し、その結果を出力する例です。

class MyClass:
    pass

my_instance = MyClass()
setattr(my_instance, 'x', 10)

print(my_instance.x)  # 10

このコードでは、まず何も属性を持たないクラスMyClassを定義しています。

次に、MyClassのインスタンスを作成し、それを変数my_instanceに代入しています。

そして、setattr関数を使用してmy_instanceの属性xに値10を設定しています。

最後に、その結果を出力しています。

結果として、10が得られます。

□応用例とサンプルコード

setattr関数は、動的にオブジェクトの属性を設定する際にも使用できます。

次のコードは、文字列から属性名を作成し、その属性を設定する例です。

class MyClass:
    pass

my_instance = MyClass()

for i in range(5):
    setattr(my_instance, f'x{i}', i)

for i in range(5):
    print(getattr(my_instance, f'x{i}'))  # 0, 1, 2, 3, 4

このコードでは、まず何も属性を持たないクラスMyClassを定義しています。

次に、MyClassのインスタンスを作成し、それを変数my_instanceに代入しています。

そして、ループを使用して、文字列から作成した属性名に対応する属性を設定しています。

最後に、設定した各属性の値を出力しています。

○関数58：slice

slice関数はPythonの組み込み関数で、スライス操作を行うためのオブジェクトを作成するために使用されます。

この関数は、リストや文字列などのシーケンス型のデータから特定の範囲の要素を取り出す際に使います。

□使い方とサンプルコード

次のコードは、リストから特定の範囲の要素をスライスとして取り出し、その結果を出力する例です。

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
slicer = slice(2, 8, 2)

print(numbers[slicer])  # [2, 4, 6]

このコードでは、まずリスト[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]を変数numbersに代入しています。

次に、slice関数を使用してインデックス2から8までの範囲で2つおきに要素を取り出すためのスライスオブジェクトを生成し、それを変数slicerに代入しています。

そして、そのスライスオブジェクトを用いてnumbersから要素を取り出し、その結果を出力しています。

結果として、[2, 4, 6]というリストが得られます。

□応用例とサンプルコード

slice関数は、大きなデータから特定の範囲のデータを効率的に取り出す際にも使用できます。

次のコードは、大量の数値から特定の範囲の数値を取り出す例です。

numbers = list(range(1000000))  # 0から999999までの数値を生成
slicer = slice(500000, 500010)  # 500000から500009までの範囲を指定

print(numbers[slicer])  # [500000, 500001, 500002, 500003, 500004, 500005, 500006, 500007, 500008, 500009]

このコードでは、まず0から999999までの数値からなる大きなリストを生成し、それを変数numbersに代入しています。

次に、slice関数を使用してインデックス500000から500009までの範囲を指定するスライスオブジェクトを生成し、それを変数slicerに代入しています。

そして、そのスライスオブジェクトを用いてnumbersから要素を取り出し、その結果を出力しています。

○関数59：sorted

sorted関数はPythonの組み込み関数で、イテラブルなオブジェクト（リストやタプルなど）の要素を並び替えた新しいリストを生成するために使用されます。

この関数は、要素の昇順や降順の並び替え、カスタムの並び替え条件の指定などが可能です。

□使い方とサンプルコード

次のコードは、リストの要素を並び替えて、その結果を出力する例です。

numbers =[5, 2, 9, 1, 5, 6, 8, 3]
sorted_numbers = sorted(numbers)

print(sorted_numbers)  # [1, 2, 3, 5, 5, 6, 8, 9]

このコードでは、まずリスト[5, 2, 9, 1, 5, 6, 8, 3]を変数numbersに代入しています。

次に、sorted関数を使用してnumbersの要素を昇順に並び替えた新しいリストを生成し、それを変数sorted_numbersに代入しています。

そして、その結果を出力しています。

結果として、[1, 2, 3, 5, 5, 6, 8, 9]という並び替えられたリストが得られます。

□応用例とサンプルコード

sorted関数は、カスタムの並び替え条件を指定するためのkeyパラメータを持っています。

次のコードは、文字列のリストを文字列の長さで並び替える例です。

words = ["apple", "banana", "cherry", "date", "elderberry"]
sorted_words = sorted(words, key=len)

print(sorted_words)  # ['date', 'apple', 'cherry', 'banana', 'elderberry']

このコードでは、まず文字列のリスト[“apple”, “banana”, “cherry”, “date”, “elderberry”]を変数wordsに代入しています。

次に、sorted関数を使用してwordsの要素を文字列の長さで並び替えた新しいリストを生成し、それを変数sorted_wordsに代入しています。

そして、その結果を出力しています。

結果として、[‘date’, ‘apple’, ‘cherry’, ‘banana’, ‘elderberry’]という並び替えられたリストが得られます。

○関数60：staticmethod

Pythonでは、クラスの中で定義されるメソッド（関数）は基本的にそのクラスのインスタンス（オブジェクト）からしか呼び出せません。

しかし、staticmethodはその限りではありません。

staticmethodは、クラスから直接呼び出せる関数を定義するためのデコレータです。

そのため、staticmethodで定義されたメソッドは、クラスの状態や属性に影響を与えない、関連する処理を一箇所にまとめることができます。

□使い方とサンプルコード

staticmethodを用いてクラス内部で関数を定義し、その関数をクラスから直接呼び出すコードの一例を紹介します。

class MyClass:
    @staticmethod
    def greet(name):
        return "Hello, " + name + "!"

print(MyClass.greet("Alice"))  # Hello, Alice!

このコードでは、まずMyClassという名前のクラスを定義しています。

その中で、staticmethodデコレータを用いてgreetという名前の関数を定義しています。

このgreet関数は引数として名前を受け取り、その名前を使って挨拶のメッセージを生成して返します。

そして、最後にMyClass.greet(“Alice”)というコードで、クラスから直接greet関数を呼び出しています。

この結果、挨拶のメッセージ”Hello, Alice!”が得られます。

□応用例とサンプルコード

staticmethodを使うと、クラス内部で一貫した機能を提供することが可能です。

たとえば、数学の計算をまとめたMathClassを作る場合、その中に静的メソッドとして平方根や平方などの計算関数を定義することができます。

import math

class MathClass:
    @staticmethod
    def square(n):
        return n ** 2

    @staticmethod
    def sqrt(n):
        return math.sqrt(n)

print(MathClass.square(4))  # 16
print(MathClass.sqrt(4))  # 2.0

このコードでは、まずMathClassという名前のクラスを定義し、その中にstaticmethodデコレータを用いてsquare（平方）とsqrt（平方根）の二つの関数を定義しています。

そして、MathClass.square(4)やMathClass.sqrt(4)というコードで、それぞれの関数を直接呼び出しています。

結果として、16や2.0という計算結果が得られます。

○関数61：str

str関数はPythonの組み込み関数で、引数として与えられたオブジェクトを文字列に変換します。

数値を文字列に変換したり、リストや辞書を文字列形式にしたりする際によく使用します。

□使い方とサンプルコード

str関数を用いて、数値を文字列に変換する基本的なコードを紹介します。

num = 12345
str_num = str(num)

print(str_num)  # '12345'
print(type(str_num))  # <class 'str'>

このコードでは、まず数値12345を変数numに代入しています。

次に、str関数を使用してnumを文字列に変換し、それを変数str_numに代入しています。

そして、その結果と変換後の型を出力しています。

結果として、’12345’という文字列とその型が得られます。

□応用例とサンプルコード

str関数は、リストや辞書などの複雑なデータ型を文字列形式に変換する際にも使われます。

リストを文字列に変換するコードの一例を紹介します。

my_list = [1, 2, 3, 4, 5]
str_list = str(my_list)

print(str_list)  # '[1, 2, 3, 4, 5]'
print(type(str_list))  # <class 'str'>

このコードでは、まずリスト[1, 2, 3, 4, 5]を変数my_listに代入しています。

次に、str関数を使用してmy_listを文字列に変換し、それを変数str_listに代入しています。

そして、その結果と変換後の型を出力しています。結果として、'[1, 2, 3, 4, 5]’という文字列とその型が得られます。

○関数62：sum

Pythonのsum関数は、数値を含むイテラブル（リスト、タプルなど）を引数に取り、その要素の合計を計算します。

□使い方とサンプルコード

sum関数を使ってリストの要素を合計する基本的なコードを紹介します。

numbers = [1, 2, 3, 4, 5]
total = sum(numbers)

print(total)  # 15

このコードでは、まず数字のリストnumbersを定義しています。

その後、sum関数を使ってリストnumbersの全要素を合計し、その結果を変数totalに格納しています。

最終的に15という結果が出力されます。

□応用例とサンプルコード

sum関数の第二引数には、初期値を指定することができます。

これにより、合計計算の初期値を0以外の値に設定することが可能です。

numbers = [1, 2, 3, 4, 5]
total = sum(numbers, 10)

print(total)  # 25

このコードでは、リストnumbersの全要素を合計する際の初期値を10に設定しています。

その結果、リストの全要素と初期値の合計である25が出力されます。

○関数63: super

super関数は、Pythonのクラス継承において、親クラスのメソッドをサブクラスから呼び出すための関数です。

これにより、サブクラスで親クラスのメソッドをオーバーライド（上書き）しても、オーバーライド前の親クラスのメソッドを利用することが可能となります。

□使い方とサンプルコード

下記のコードは、super関数を使用して親クラスのメソッドを呼び出す基本的な使用例です。

class Parent:
    def greet(self):
        return "Hello!"

class Child(Parent):
    def greet(self):
        return super().greet() + " from the Child class."

child = Child()
print(child.greet())  # "Hello! from the Child class."

このコードでは、まずParentクラスを定義し、その中にgreetメソッドを実装しています。

次にChildクラスを定義し、Parentクラスを継承します。

Childクラスでもgreetメソッドを定義していますが、その中でsuper

関数を使用して親クラスParentのgreetメソッドを呼び出し、その結果に” from the Child class.”という文字列を追加しています。

最後に、Childクラスのインスタンスを作成し、そのgreetメソッドを呼び出すと、”Hello! from the Child class.”という結果が得られます。

□応用例とサンプルコード

次に、super関数を使った応用例を示します。

この例では、親クラスのメソッドを呼び出して、その結果を基にサブクラスのメソッドで処理を追加します。

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Square(Rectangle):
    def __init__(self, side):
        super().__init__(side, side)

square = Square(4)
print(square.area())  # 16

このコードでは、まずRectangleクラス（親クラス）を定義しています。

このクラスには幅と高さを属性として持ち、それらの積を計算するareaメソッドがあります。

次に、Squareクラス（子クラス）を定義し、Rectangleクラスを継承します。

Squareクラスのinitメソッドでは、引数として一辺の長さを受け取り、それを親クラスのinitメソッドに渡すことで、四角形が正方形であることを表現しています。

最後に、一辺の長さが4のSquareクラスのインスタンスを作成し、その面積を計算します。結果は16となります。

○関数64：tuple

tuple関数は、引数として与えられたイテラブル（リスト、文字列など）をタプルに変換します。

□使い方とサンプルコード

下記のコードは、リストをタプルに変換する基本的な使用例です。

my_list = [1, 2, 3, 4, 5]
my_tuple = tuple(my_list)

print(my_tuple)  # (1, 2, 3, 4, 5)
print(type(my_tuple))  # <class 'tuple'>

このコードでは、まず数値のリストmy_listを定義しています。

その後、tuple関数を使ってリストmy_listをタプルに変換し、その結果を変数my_tupleに格納しています。

最終的にタプル(1, 2, 3, 4, 5)とその型が出力されます。

□応用例とサンプルコード

tuple関数は、文字列を1文字ずつの要素を持つタプルに変換するのにも使用できます。

my_string = "Python"
my_tuple = tuple(my_string)

print(my_tuple)  # ('P', 'y', 't', 'h', 'o', 'n')

このコードでは、文字列”Python”をタプルに変換しています。

その結果、各文字が個々の要素となったタプル(‘P’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’)が生成されます。

○関数65：type

type関数は、オブジェクトの型を返す組み込み関数です。

引数としてオブジェクトを一つだけ与えると、そのオブジェクトの型を返します。

□使い方とサンプルコード

下記のコードは、異なる種類のオブジェクトの型を確認するための基本的な使用例です。

print(type(123))  # <class 'int'>
print(type(123.456))  # <class 'float'>
print(type("Hello, Python!"))  # <class 'str'>

このコードでは、type関数を用いて整数、浮動小数点数、文字列のそれぞれの型を確認しています。

それぞれ、、、と表示され、それぞれのオブジェクトがint型、float型、str型であることが確認できます。

□応用例とサンプルコード

type関数は、カスタムクラスのインスタンスの型を確認するのにも使用できます。

class MyClass:
    pass

my_instance = MyClass()
print(type(my_instance))  # <class '__main__.MyClass'>

このコードでは、まずカスタムクラスMyClassを定義しています。

その後、そのクラスのインスタンスを生成し、そのインスタンスの型をtype関数を用いて確認しています。

結果として、と表示され、my_instanceがMyClassのインスタンスであることが確認できます。

○関数66：vars

vars関数は、オブジェクトの属性とその値からなる辞書を返す組み込み関数です。

引数としてオブジェクトを一つ与えると、そのオブジェクトのdict属性を返します。

□使い方とサンプルコード

下記のコードは、カスタムクラスのインスタンスの属性とその値を表示するための基本的な使用例です。

class MyClass:
    def __init

__(self, a, b):
        self.a = a
        self.b = b

my_instance = MyClass(123, "Hello")

print(vars(my_instance))  # {'a': 123, 'b': 'Hello'}

このコードでは、まずカスタムクラスMyClassを定義し、その中でaとbという属性を定義しています。

次に、そのクラスのインスタンスを生成し、その際にaとbの属性に値を設定しています。

最後に、vars関数を使ってインスタンスmy_instanceの属性とその値を表示しています。

結果として、{‘a’: 123, ‘b’: ‘Hello’}と表示され、my_instanceがaとbという属性を持ち、それぞれの値が123と”Hello”であることが確認できます。

さて、Pythonの組み込み関数の解説もいよいよ終盤に差し掛かりました。次にご紹介するのは「zip」関数です。

○関数67：zip

zip関数は、複数のイテラブル（リストやタプルなど）を引数に取り、それぞれのイテラブルから同じインデックスにある要素を取り出し、タプルとしてまとめます。

その結果をイテレータとして返します。

□使い方とサンプルコード

ここでは、二つのリストをzip関数に与え、それぞれのリストから同じ位置にある要素をまとめたタプルを作る例をご紹介します。

list1 = [1, 2, 3]
list2 = ['one', 'two', 'three']

zipped = zip(list1, list2)

for item in zipped:
    print(item)

このコードを実行すると次のような出力結果が得られます。

(1, 'one')
(2, 'two')
(3, 'three')

上記のコードでは、まずlist1とlist2という二つのリストを定義しています。

それぞれのリストには三つの要素があります。

次に、zip関数を使ってこれら二つのリストをまとめ、結果をzippedという変数に代入します。

そして、forループを使ってzippedに含まれる各タプルを表示しています。

□応用例とサンプルコード

zip関数は、複数のリストからデータを一度に取り出して処理を行うときに便利です。

例えば、一つ目のリストに名前、二つ目のリストに年齢が格納されている場合に、それぞれの人の名前と年齢を一緒に表示することができます。

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]

for name, age in zip(names, ages):
    print(f'{name} is {age} years old.')

このコードを実行すると次のような出力結果が得られます。

Alice is 25 years old.
Bob is 30 years old.
Charlie is 35 years old.

ここでは、まずnamesとagesという二つのリストを定義しています。

それぞれのリストには三つの要素があります。

次に、zip関数を使ってこれら二つのリストをまとめ、結果をforループで一つずつ取り出しています。

そして、各人の名前と年齢を一緒に表示しています。

○関数68：import

Pythonのプログラムが巨大化してくると、全てのコードを一つのファイルに書くのは困難になります。

そこで、Pythonでは複数のファイルにコードを分割して記述することができます。

そして、そのように分割されたコード（モジュール）を読み込むために使用するのが「import」です。

□使い方とサンプルコード

ここでは、Pythonの標準ライブラリであるmathモジュールをimportし、その中にあるsqrt関数を使って平方根を計算する例を見てみましょう。

import math

print(math.sqrt(16))  # 出力: 4.0

このコードでは、まずmathモジュールをimportしています。

そして、mathモジュールに含まれるsqrt関数を使って、16の平方根を計算しています。結果は4.0と表示されます。

□応用例とサンプルコード

モジュールから特定の関数だけを取り出して使いたいときには、from…import文を使用します。

また、asを使用することで、モジュールや関数に別名を付けることもできます。

from math import sqrt as square_root

print(square_root(16))  # 出力: 4.0

このコードでは、mathモジュールからsqrt関数をimportし、それにsquare_rootという別名を付けています。

そのため、square_rootという名前でsqrt関数を呼び出すことができます。

結果として、16の平方根である4.0が表示されます。

まとめ

Pythonの組み込み関数68選の解説を通じて、Pythonの機能とその使い方について詳しく学んできました。

それぞれの関数がどのような動作をするのか、どのように使用するのか、そしてそれぞれの関数がどのような場面で役立つのかについての理解を深めることができたでしょう。

これらの組み込み関数を使うことで、Pythonのプログラミングがよりスムーズで効率的になります。

さまざまな関数を組み合わせて使うことで、Pythonのパワフルな機能を最大限に引き出すことができます。

この記事を読んで、Pythonの組み込み関数の使い方について理解が深まったことを願っています。

これらの知識をもとに、Pythonでのプログラミングを楽しんでください。