Pythonの初心者レッスンーーPythonの基本データ型

Pythonの変数代入

Pythonで変数に値を代入するには、以下のように等号（=）を使用します：

変数名 = 値

• 普通の例：

x = 10
pi = 3.14
name = "Alice"
fruits = ["apple", "banana", "cherry"]

• 複数変数への同時代入：

a, b, c = 1, 2, 3

ここでは、変数aに1、bに2、cに3を同時に代入しています。

• 同じ値を複数の変数に代入：

x = y = z = 0

ここでは、変数x、y、z全てに0を代入しています。

標準データ型

Python3には、いくつかの基本的なデータ型があります。これらのデータ型は、プログラミングにおいて最も頻繁に使用される基本的なデータ構造を表します。以下は、Python3の主要な基本データ型です：

1. 整数型（int）：

   • 整数を表すデータ型です。例: 1, 100, -42

2. 浮動小数点数型（float）：

   • 浮動小数点数（小数部分を持つ数）を表すデータ型です。例: 3.14, 0.001, -2.718

3. 文字列型（str）：

   • 文字の並び（文字列）を表すデータ型です。例: "hello", "Python", "123"

4. ブール型（bool）：

   • 真理値（True または False）を表すデータ型です。例: True, False

5. リスト型（list）：

   • 複数の値を順序付けて保持することができるデータ型です。リストは変更可能です。例: [1, 2, 3], ["apple", "banana", "cherry"]

6. タプル型（tuple）：

   • 複数の値を順序付けて保持することができるデータ型ですが、リストと異なり変更不可です。例: (1, 2, 3), ("apple", "banana", "cherry")

7. 辞書型（dict）：

   • キーと値のペアを保持するデータ型です。例: {"name": "Alice", "age": 25}, {"apple": "red", "banana": "yellow"}

8. 集合型（set）：

   • ユニークな値の集まりを保持するデータ型です。例: {1, 2, 3}, {"apple", "banana", "cherry"}

数値型（number）

Pythonの数値型とは、数値を扱うためのデータ型の総称です。Pythonには、主に次の3つの基本的な数値型があります：

• 整数型（int）
• 浮動小数点数型（float）
• 複素数型（complex）

整数型（int）

整数型（int）は、小数点を含まない整数を表します。Pythonの整数は、サイズに制限がなく、必要に応じてメモリが許す限り大きな数を扱うことができます。
例：

a = 42
b = -99
c = 0

x = 10
y = 3

# 加算
print(x + y)  # 出力: 13

# 減算
print(x - y)  # 出力: 7

# 乗算
print(x * y)  # 出力: 30

# 除算
print(x / y)  # 出力: 3.3333333333333335 (float)

# 整数除算
print(x // y)  # 出力: 3

# 余り
print(x % y)  # 出力: 1

# べき乗
print(x ** y)  # 出力: 1000

浮動小数点数型（float）

浮動小数点数型（float）は、小数点を含む数を表します。浮動小数点数は近似値として表現されるため、非常に大きな数や非常に小さな数を扱うことができますが、精度には限界があります。
例：

a = 3.14
b = -0.001
c = 1.0

x = 10.5
y = 2.5

# 加算
print(x + y)  # 出力: 13.0

# 減算
print(x - y)  # 出力: 8.0

# 乗算
print(x * y)  # 出力: 26.25

# 除算
print(x / y)  # 出力: 4.2

# 整数除算
print(x // y)  # 出力: 4.0

# 余り
print(x % y)  # 出力: 0.5

# べき乗
print(x ** y)  # 出力: 187.1447090887009

複素数型（complex）

複素数型（complex）は、実数部と虚数部からなる数を表します。虚数部は、jまたはJで表されます。
例：

a = 2 + 3j
b = -1j
c = 4.5 + 0j

x = 1 + 2j
y = 3 + 4j

# 加算
print(x + y)  # 出力: (4+6j)

# 減算
print(x - y)  # 出力: (-2-2j)

# 乗算
print(x * y)  # 出力: (-5+10j)

# 除算
print(x / y)  # 出力: (0.44+0.08j)

数値型の変換

Pythonでは、int、float、complexの間で型変換を行うことができます。

• intからfloatへの変換

x = 5
y = float(x)
print(y)  # 出力: 5.0

• floatからintへの変換

x = 5.7
y = int(x)
print(y)  # 出力: 5

• intまたはfloatからcomplexへの変換

x = 3
y = complex(x)
print(y)  # 出力: (3+0j)

z = 4.5
w = complex(z)
print(w)  # 出力: (4.5+0j)

文字列型（str）

この文章を参照してください！
https://zenn.dev/datasciencekun/articles/3979d693d19fa7#文字列

文字列のインデックス

Pythonでは、文字列はインデックスを使ってアクセスすることができます。文字列のインデックスは0から始まり、負のインデックスを使うと末尾から数えることもできます。
例：

s = "Hello"
print(s[0])  # 出力: H
print(s[1])  # 出力: e
print(s[-1]) # 出力: o
print(s[-2]) # 出力: l

エスケープ文字

エスケープ文字（エスケープシーケンス）は、バックスラッシュ \ を使って特殊な文字や機能を表現するために使われます。
主なエスケープ文字の例:

• \ : バックスラッシュ自身
• ' : シングルクォート
• " : ダブルクォート
• \n : 改行
• \t : タブ
  例：

s = "He said, \"Hello!\"\nHow are you?"
print(s)

出力:

He said, "Hello!"
How are you?

ブール型（bool）

Pythonのブール型（bool）は、真偽値を表すデータ型です。ブール型は、プログラムの条件分岐や論理演算において非常に重要な役割を果たします。Pythonでは、TrueとFalseの2つの値を持ちます。

特徴

1. 値:
   • True (真)
   • False (偽)
2. 型:
   • ブール型の値はbool型です。

例：

is_active = True
is_logged_in = False

ブール型の基本操作

ブール型は、論理演算子と組み合わせて使用されます。以下は、Pythonで使用できる主な論理演算子です。
論理演算子

1. AND (and)
   • 両方の条件がTrueの場合にTrueを返します。

print(True and True)   # 出力: True
print(True and False)  # 出力: False

2. OR (or)
   • いずれかの条件がTrueの場合にTrueを返します

print(True or False)  # 出力: True
print(False or False) # 出力: False

3. NOT (not)
   • ブール値を反転させます。

print(not True)  # 出力: False
print(not False) # 出力: True

ブール型と条件分岐

ブール型は、条件分岐（if文）でよく使用されます。

is_admin = True

if is_admin:
    print("You have admin access.")
else:
    print("You do not have admin access.")

ブール型への変換

Pythonでは、他のデータ型をブール型に変換することができます。以下のような変換ルールがあります。

• 0、None、空のシーケンス（""、[]、()など）はFalseに評価されます。
• それ以外の値はすべてTrueに評価されます。
  例：

print(bool(0))       # 出力: False
print(bool(1))       # 出力: True
print(bool(""))      # 出力: False
print(bool("Hello")) # 出力: True
print(bool([]))      # 出力: False
print(bool([1, 2, 3])) # 出力: True

リスト型（list）

Pythonのリスト型（list）は、複数の要素を一つのコレクションとして格納するためのデータ型です。リストは変更可能（ミュータブル）で、要素を追加、削除、変更することができます。

特徴

• 順序: リストは順序付けられたコレクションであり、要素にはインデックスでアクセスできます。
• 変更可能: リストは変更可能であり、要素を追加、削除、変更することができます。
• 多様な要素: リストは異なるデータ型の要素を含むことができます（例えば、整数、文字列、他のリストなど）。

リストの作成

リストは角括弧[]を使って作成します。リストの要素はカンマ,で区切ります。

# 空のリスト
empty_list = []

# 要素を含むリスト
numbers = [1, 2, 3, 4, 5]
fruits = ["apple", "banana", "cherry"]
mixed = [1, "apple", 3.14, [1, 2, 3]]

リストの操作

• 要素へのアクセス
  リストの要素にはインデックスを使ってアクセスできます。インデックスは0から始まり、負のインデックスを使うと末尾からアクセスできます。

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

print(fruits[0])   # 出力: apple
print(fruits[1])   # 出力: banana
print(fruits[-1])  # 出力: cherry

• 要素の変更
  リストの特定の要素を変更するには、インデックスを使って新しい値を割り当てます。

fruits = ["apple", "banana", "cherry"]
fruits[1] = "blueberry"
print(fruits)  # 出力: ['apple', 'blueberry', 'cherry']

• 要素の追加
  appendメソッドを使ってリストの末尾に要素を追加できます。また、insert メソッドを使って特定の位置に要素を挿入することもできます。

fruits = ["apple", "banana", "cherry"]
fruits.append("date")
print(fruits)  # 出力: ['apple', 'banana', 'cherry', 'date']

fruits.insert(1, "blueberry")
print(fruits)  # 出力: ['apple', 'blueberry', 'banana', 'cherry', 'date']

• 要素の削除
  removeメソッドを使って特定の要素を削除したり、pop メソッドを使って特定の位置の要素を削除したりできます。del キーワードを使ってインデックスを指定して要素を削除することもできます。

fruits = ["apple", "banana", "cherry"]
fruits.remove("banana")
print(fruits)  # 出力: ['apple', 'cherry']

fruits.pop(1)
print(fruits)  # 出力: ['apple']

del fruits[0]
print(fruits)  # 出力: []

• リストの長さ
  len関数を使ってリストの長さ（要素の数）を取得できます。

fruits = ["apple", "banana", "cherry"]
print(len(fruits))  # 出力: 3

• リストのスライス
  リストの部分を取得するためにスライスを使用できます。スライス構文はlist[start:end:step]です。

numbers = [1, 2, 3, 4, 5]
print(numbers[1:3])   # 出力: [2, 3]
print(numbers[:3])    # 出力: [1, 2, 3]
print(numbers[2:])    # 出力: [3, 4, 5]
print(numbers[::2])   # 出力: [1, 3, 5]
print(numbers[::-1])  # 出力: [5, 4, 3, 2, 1]

タプル型（tuple）

Pythonのタプル型（tuple）は、複数の要素を一つにまとめて管理できるデータ型の一つです。タプルは、リストと似ていますが、タプルはイミュータブル（不変）である点が異なります。つまり、一度作成されたタプルの要素は変更できません。タプルは、カンマで区切られた値の並びを丸括弧()で囲んで定義します。

タプルの作成

タプルを作成するには、次のようにします。

# 空のタプル
empty_tuple = ()

# 1つの要素を持つタプル
one_element_tuple = (1,)

# 複数の要素を持つタプル
multiple_element_tuple = (1, 2, 3, 4)

# 異なるデータ型を混在させたタプル
mixed_tuple = (1, "apple", 3.14)

タプルの特性

1. イミュータブル:

   • タプルの要素は変更できません。要素を追加したり削除したりすることはできません。

2. インデックス:

   • リストと同様に、タプルの要素にはインデックスを使用してアクセスできます。インデックスは0から始まります。

3. ネスト:

   • タプルはネスト可能です。つまり、タプルの中にタプルを含めることができます。

タプルの操作

タプルの基本的な操作には以下のようなものがあります。
要素へのアクセス

my_tuple = (1, 2, 3, 4)
print(my_tuple[0])  # 1
print(my_tuple[2])  # 3

ネストされたタプルへのアクセス

nested_tuple = (1, (2, 3), 4)
print(nested_tuple[1])    # (2, 3)
print(nested_tuple[1][0]) # 2

スライシング

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[1:4])  # (2, 3, 4)

タプルの結合

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined_tuple = tuple1 + tuple2
print(combined_tuple)  # (1, 2, 3, 4, 5, 6)

タプルの長さを取得

my_tuple = (1, 2, 3, 4, 5)
print(len(my_tuple))  # 5

タプルの利用例

タプルは、そのイミュータブルな性質から、固定された値の集合を扱うときや、関数から複数の値を返すときに便利です。
関数から複数の値を返す

def min_max(numbers):
    return (min(numbers), max(numbers))

result = min_max([1, 2, 3, 4, 5])
print(result)  # (1, 5)

辞書型（dict）

Pythonの辞書型（dict）は、キーと値のペアを保持するデータ型です。辞書型は、リストやタプルと異なり、順序付けられたデータのコレクションではなく、キーを使って値にアクセスします。辞書型は非常に柔軟で、高速なキー検索を提供します。

辞書の作成

辞書は波括弧{}を使って定義し、キーと値のペアをコロン:で区切ります。各ペアはカンマ,で区切ります。

# 空の辞書を作成
empty_dict = {}

# キーと値のペアを持つ辞書を作成
person = {
    "name": "Alice",
    "age": 25,
    "city": "New York"
}

辞書の特性

1. キーと値のペア:

   • 辞書はキーと値のペアで構成されます。キーはユニークでなければならず、変更できない（イミュータブル）型（例えば、文字列、数値、タプル）でなければなりません。値は任意の型を持つことができます。

2. 順序付け（Python 3.7以降）:

   • Python 3.7以降では、辞書は挿入順序を保持します。それ以前のバージョンでは、順序は保証されません。

辞書の操作

辞書に対する基本的な操作には、以下のようなものがあります。
要素へのアクセス

print(person["name"])  # "Alice"
print(person["age"])   # 25

要素の追加と更新

person["email"] = "[e-mail]"  # 新しいキーと値のペアを追加
person["age"] = 26  # 既存のキーの値を更新

要素の削除

del person["city"]  # 指定したキーとその値を削除

キーの存在確認

if "name" in person:
    print("Name is present")

辞書のメソッド
- keys(): すべてのキーを取得
- values(): すべての値を取得
- items(): すべてのキーと値のペアを取得

print(person.keys())    # dict_keys(['name', 'age', 'email'])
print(person.values())  # dict_values(['Alice', 26, '[e-mail]'])
print(person.items())   # dict_items([('name', 'Alice'), ('age', 26), ('email', '[e-mail]')])

辞書の反復処理
辞書をループ処理する場合、キーと値のペアを簡単に取得できます。

for key, value in person.items():
    print(f"{key}: {value}")

辞書の利用例

辞書は、多くの実用的な用途に使用されます。例えば、設定ファイルのデータを管理したり、データベースのレコードを表現したり、カウントやグルーピングの操作を行ったりします。
設定データの管理

config = {
    "host": "localhost",
    "port": 8080,
    "debug": True
}

カウント操作

word_count = {}
text = "hello world hello"
words = text.split()

for word in words:
    if word in word_count:
        word_count[word] += 1
    else:
        word_count[word] = 1

print(word_count)  # {'hello': 2, 'world': 1}

集合型（set）

Pythonの集合型（set）は、重複しない要素のコレクションを保持するデータ型です。集合は数学の集合と同じように、要素の重複を許さず、順序がありません。Pythonでは、setとfrozensetの2種類の集合型があります。setは変更可能（ミュータブル）であり、frozensetは変更不可能（イミュータブル）です。

集合の作成

集合は波括弧{}を使用して作成するか、set()コンストラクタを使用して作成します。

# 空の集合を作成
empty_set = set()

# 要素を持つ集合を作成
fruits = {"apple", "banana", "cherry"}

集合の特性

1. 重複のない要素:

   • 集合には同じ要素を複数回含めることはできません。

2. 順序がない:

   • 集合の要素には順序がありません。そのため、インデックスによるアクセスはできません。

集合の操作

集合に対する基本的な操作には、以下のようなものがあります。
要素の追加

fruits.add("orange")  # 集合に要素を追加

要素の削除

fruits.remove("banana")  # 指定した要素を削除（要素が存在しない場合、エラーが発生）
fruits.discard("grape")  # 指定した要素を削除（要素が存在しなくてもエラーは発生しない）

要素の存在確認

print("apple" in fruits)  # 要素が集合に含まれているかどうかを確認

集合の基本演算
集合は数学の集合演算に対応するメソッドを提供しています。

• 和集合:

set1 = {"apple", "banana", "cherry"}
set2 = {"cherry", "date", "fig"}
union_set = set1 | set2  # {"apple", "banana", "cherry", "date", "fig"}
union_set = set1.union(set2)

• 積集合:

intersection_set = set1 & set2  # {"cherry"}
intersection_set = set1.intersection(set2)

• 差集合:

difference_set = set1 - set2  # {"apple", "banana"}
difference_set = set1.difference(set2)

• 対称差集合:

symmetric_difference_set = set1 ^ set2  # {"apple", "banana", "date", "fig"}
symmetric_difference_set = set1.symmetric_difference(set2)

集合の利用例

集合は、その重複を許さない性質と高速な要素の確認能力から、データの一意性の保証や重複の排除などに利用されます。
重複の排除

items = ["apple", "banana", "apple", "cherry"]
unique_items = set(items)  # {"apple", "banana", "cherry"}

要素の共通部分を見つける

list1 = ["apple", "banana", "cherry"]
list2 = ["banana", "cherry", "date"]
common_items = set(list1) & set(list2)  # {"banana", "cherry"}

データ型変換の内置関数

Pythonには、データ型を相互に変換するための多くの内置関数（ビルトイン関数）があります。これらの関数は、特定のデータ型に変換するために使用されます。

関数	説明	例
int()	引数を整数型に変換します	int("123") → 123 int(123.45) → 123
float()	引数を浮動小数点数型に変換します	float("123.45") → 123.45 float(123) → 123.0
str()	引数を文字列型に変換します	str(123) → "123" str(123.45) → "123.45"
bool()	引数をブール型に変換します	bool(1) → True bool(0) → False
list()	引数をリスト型に変換します	list((1, 2, 3)) → [1, 2, 3] list("abc") → ['a', 'b', 'c']
tuple()	引数をタプル型に変換します	tuple([1, 2, 3]) → (1, 2, 3) tuple("abc") → ('a', 'b', 'c')
set()	引数をセット型に変換します	set([1, 2, 2, 3]) → {1, 2, 3} set("abc") → {'a', 'b', 'c'}
dict()	引数を辞書型に変換します（通常はキーと値のペアから）	dict([("a", 1), ("b", 2)]) → {'a': 1, 'b': 2}
complex()	引数を複素数型に変換します	complex(1, 2) → (1+2j) complex("1+2j") → (1+2j)