Pythonのデータ型を徹底攻略！型の種類から型ヒントまで詳しく解説

  • Python
  • データ型
最終更新日:

この記事のポイント

この記事では、Pythonでプログラミングを始める際に必ず理解しておきたい型（データ型）について、基本概念から実践的な活用方法まで解説します。

この記事を読むと、次のようなことがわかります。

  • 動的型付け言語としてのPythonの特徴
  • 型の基本概念について
  • int・str・listなど主要なデータ型の使い方と特徴
  • 型の確認のやり方や型の変換方法
  • 型ヒントを使った開発効率向上の方法
  • クラスを使った独自型

型はプログラミングの土台となる概念です。

変数にどんな種類のデータが入っているのかを正しく理解できないと、計算ミスやエラーの原因を見つけられず、プログラムが思った通りに動きません。

逆に、型を適切に扱えるようになれば、エラーを未然に防ぎ、バグの少ない安全なプログラムを書けるようになります。

この記事を通して、Pythonにおける型の扱い方をしっかり身に付けましょう。

目次

「型」（データ型）とは？

プログラミングにおける「型」とは、データの種類や性質を表す概念です。

例えば、「3」という数値と「ネコ」という文字は、コンピューターにとってまったく異なる種類のデータです。数値なら計算ができますが、文字では計算ができません。

このように、データの種類によってできることが変わってきます。

型を理解することで、データを適切に操作し、エラーを防ぎながら効率的なプログラムを作成できるようになります。そんな型について、1つずつ学んでいきましょう。

【関連】
Pythonをもっと詳しく学ぶならpaizaラーニング

データ型の定義と役割

型は、「そのデータで何ができるか」を決める大事な情報です。くわしい言い方をすると、メモリ内のデータがどのような値を持ち、どのような操作が可能かを定義します。

例えば、数値型なら足し算や引き算ができます。文字列型なら文字をつなげたり、大文字に変えたりできます。

このように、型によって使える機能が決まっているということです。

number = 10 text = "ネコ" print(number + 5) print(text + "好き")







出力結果
15
ネコ好き
この例では、同じ+という記号を使っていますが、型によって動作が変わります。数値の場合は足し算、文字列の場合はつなげる処理になります。
Pythonが「動的型付け言語」と呼ばれる理由
Pythonでは、変数を作るときに型を指定する必要がありません。
他のプログラミング言語（JavaやC言語など）では、「この変数は整数です」「この変数は文字列です」とあらかじめ宣言する必要があります。しかし、Pythonは値を見て自動的に型を判断してくれるため、初心者にも扱いやすいのが特徴です。
この仕組みを動的型付けと呼びます。

  
animal = "イヌ"
animal = 100
print(animal)

  


  







出力結果
100
このように、同じ変数に文字列を入れた後、数値を代入することもできます。このような柔軟さが初心者にとって扱いやすい理由の一つです。
Pythonで扱える主な型
Pythonには、用途に応じてさまざまな型が用意されています。
それぞれの型には独自の特徴があり、データの性質に合わせて使い分けることで効果的なプログラムを書くことができます。
よく使われる基本的な型から順番に見ていきましょう。
代表的な基本型（int・float・str・bool）
Pythonでよく使われる基本的な型には、次の4つがあります。
    

  • 
整数型（int）: マイナスの数、ゼロ、プラスの数を表現する型
    • 

  • 
小数型（float）: 小数点以下を含む数値を表現する型
    • 

  • 
文字列型（str）: 文字の集まりを表現する型
    • 

  • 
真偽値型（bool）: TrueまたはFalseの二つの値だけを持つ型
    • 

この4つは日常的なプログラミングで必ず使う型なので、しっかり理解しておきましょう。
整数型（int） 
整数型は、マイナスの数、ゼロ、プラスの数を表現する型です。足し算、引き算、掛け算、割り算など、基本的な計算が可能です。
ちなみに、Pythonの整数型は他の言語と違って、理論上は無制限に大きな数を扱うことができるという特徴があります。
実際に、基本的な計算をしているコード例を見てみましょう。

  
cat_age = 3
dog_age = 5
total_age = cat_age + dog_age
age_difference = dog_age - cat_age

print(f"合計年齢: {total_age}歳")
print(f"年齢差: {age_difference}歳")
print(f"掛け算: {cat_age * 4}")
print(f"べき乗: {2 ** 3}")

  


  







出力結果
合計年齢: 8歳
年齢差: 2歳
掛け算: 12
べき乗: 8
整数を使った基本的な計算を実行しているのが確認できますね。
ちなみに、**はべき乗（累乗）を計算する演算子で、2 ** 3は「2の3乗」という意味です。
浮動小数点数型（float） 
浮動小数点数型は小数を表現するための型です。
小数点以下の数値を扱う場合や、割り算の結果が小数になる場合に使います。
科学的記法（例：1.23e-4）でも記述できます。
浮動小数点数の計算例を示します。

  
hamster_weight = 0.12
guinea_pig_weight = 1.5
average_weight = (hamster_weight + guinea_pig_weight) / 2

print(f"ハムスターの体重: {hamster_weight}kg")
print(f"モルモットの体重: {guinea_pig_weight}kg")
print(f"平均体重: {average_weight}kg")
print(f"科学的記法: {1.23e-4}")

  


  







出力結果
ハムスターの体重: 0.12kg
モルモットの体重: 1.5kg
平均体重: 0.81kg
科学的記法: 0.000123
小数を扱う際によく問題になるのは、誤差です。
コンピュータは内部で2進数を使って計算するため、0.1のような10進数の小数を正確に表現できないことがあるのです。
これは計算ミスではなく、コンピュータの仕組み上避けられない現象です。そのため、小数を扱う際には、この誤差を考慮したプログラミングが必要になるということを覚えておきましょう。
文字列型（str） 
文字の集まりを表現するのが文字列型です。
シングルクオート（'）またはダブルクオート（"）で文字を囲んで作ります。複数の文字をつなげたり、大文字に変えたり、文字数を数えたりと、さまざまな操作ができます。
f文字列を使った文字列フォーマットも便利な機能です。

  
animal_name = "シロ"
species = "ウサギ"
full_description = f"{species}の{animal_name}"

print(f"基本情報: {full_description}")
print(f"文字数: {len(animal_name)}")
print(f"大文字変換: {'rabbit'.upper()}")
print(f"文字列分割: {'ネコ,イヌ,ウサギ'.split(',')}")

  


  







出力結果
基本情報: ウサギのシロ
文字数: 2
大文字変換: RABBIT
文字列分割: ['ネコ', 'イヌ', 'ウサギ']
この例では、さまざまな操作を実行しています。
    

  • 
len(): 文字数を数える
    • 

  • .upper(): 大文字に変換する
    • 

  • .split(): カンマで区切って分割する
    • 

文字列に関する基本的な操作として、覚えておきましょう。
真偽値型（bool） 
真偽値型は、TrueまたはFalseの二つの値だけを持つ型です。
「はい」か「いいえ」の判断が必要な場面で使います。if文やwhile文などの条件判断で重要な役割を果たします。空の値や0はFalse、それ以外はTrueとして評価されます。
真偽値を使った条件分岐の例を示します。

  
is_dog = True
is_hungry = False
animal_count = 3

print(f"犬かどうか: {is_dog}")
print(f"お腹がすいているか: {is_hungry}")

if is_dog and animal_count > 0:
    print("犬が" + str(animal_count) + "匹います")

print(f"空文字列の真偽値: {bool('')}")
print(f"0の真偽値: {bool(0)}")
print(f"文字列'ネコ'の真偽値: {bool('ネコ')}")

  


  







出力結果
犬かどうか: True
お腹がすいているか: False
犬が3匹います
空文字列の真偽値: False
0の真偽値: False
文字列'ネコ'の真偽値: True
ちなみに、PythonではTrue（最初が大文字）しか使えません。
trueと小文字で書くとエラーになります。これはPythonの仕様で、ブール値は必ず以下のように書く必要があります:
    

  • True（真）
    • 

  • False（偽）
    • 

JavaScriptやJavaなど他の言語ではtrue/falseと小文字で書くので、混同しやすいポイントです。Pythonでは必ず最初を大文字にするということを覚えておきましょう。
リスト型（list）
リスト型は、複数の値をまとめて管理できる便利な型です。
角括弧[]で作成し、中に入れた値を自由に追加したり、削除したり、変更したりすることができます。

  
animals = ["ネコ", "イヌ", "ウサギ"]
animals.append("ハムスター")
animals.remove("イヌ")
print(animals)

  


  







出力結果
['ネコ', 'ウサギ', 'ハムスター']
最初に、3つの動物名が入ったリストを作っています。
append()とremove()は、リストオブジェクトが持っている機能（メソッド）で、リスト名.メソッド名()という形で呼び出して使います。
次のような役割を持っているので、押さえておきましょう。
append(): 末尾に追加
remove(): 指定した値を削除
Pythonでは、このようにオブジェクトに紐づいた関数を「メソッド」と呼びます。
タプル型（tuple）
タプル型は、丸括弧()で作成する型で、作成後に中身を変更できないという特徴があります。
この「変更できない」という性質は、イミュータブル（不変）と呼びます。座標や、変えてはいけない固定的なデータを表現するのに適しています。
実際の例を見てみましょう。

  
zoo_animals = ("ライオン", "ゾウ", "キリン")
print(f"動物園には{len(zoo_animals)}種類の動物がいます")
print(f"最初の動物は{zoo_animals[0]}です")

  


  







出力結果
動物園には3種類の動物がいます
最初の動物はライオンです
このコード例では、タプルを使って動物園の動物を管理しています。len()で要素数を数え、[0]で最初の要素にアクセスしています。
集合型（set）
集合型は、重複する要素を持たず、順序も保たないデータ構造です。波括弧{}で作成し、数学の集合のように和集合や差集合といった操作ができます。
重複を自動的に取り除いてくれるため、「重複のないリストを作りたい」という場面で便利です。
実際の例を見てみましょう。

  
mammals = {"ネコ", "イヌ", "ネコ", "クマ"}
birds = {"ツバメ", "スズメ", "カラス"}
all_animals = mammals | birds

print(mammals)
print(all_animals)

  


  







出力結果（例）
{'イヌ', 'クマ', 'ネコ'}
{'イヌ', 'クマ', 'ネコ', 'ツバメ', 'スズメ', 'カラス'}
「ネコ」が2回入っていますが、集合型では重複が自動的に取り除かれるため、結果には1つだけ表示されます。
|は和集合を求める演算子です。
ちなみに、「実行する」ボタンを何度も押してみてください。順序を維持していないということが実感できるはずです。
辞書型（dict）
辞書型は、キーと値のペアでデータを管理する型です。
波括弧{}の中にkey: valueの形式で記述し、キーを指定して値を取得したり変更したりすることができます。
データベースのように、構造化された情報を管理するのに最適です。

  
pet_info = {
    "name": "ポチ",
    "species": "イヌ",
    "age": 3
}

pet_info["weight"] = 5.2

print(f"{pet_info['name']}は{pet_info['age']}歳の{pet_info['species']}です")

  


  







出力結果
ポチは3歳のイヌです
辞書型では、辞書名[新しいキー] = 値という書き方で、新しいキーと値のペアを追加することができます。
最初は「name」「species」「age」の3つの情報だけでしたが、pet_info["weight"] = 5.2という書き方で新しく「weight」という項目を追加しています。
そして、pet_info['name']のようにキーを指定することで、対応する値を取り出すことができます。
型の確認・変換・強制の方法
プログラミングでは、変数がどの型なのかを確認したり、異なる型同士でデータをやり取りするために型変換が必要になる場面があります。
Pythonには、型を調べる関数や型を変換する仕組みが豊富に用意されています。
ここでは、その仕組みについて学んでいきましょう。
type関数で型を確認する
type()関数を使うと、変数や値がどの型なのかを確認できます。
プログラムが意図通りに動かないとき、「実は文字列だと思っていたのに整数だった」といった型の勘違いがよくあります。
type()を使えば、その変数が実際にどの型なのかをすぐに確認できるため、デバッグ時に非常に役立ちます。
また、戻り値は型オブジェクトなので、if type(x) == int:のような型の比較にも使えます。
実際に確認してみましょう。

  
animal = "シマウマ"
count = 42
animals_list = ["ライオン", "トラ"]

print(type(animal))
print(type(count))
print(type(animals_list))

  


  







出力結果
<class 'str'>
<class 'int'>
<class 'list'>
3つの変数の型を確認していますね。
もし、出力された型にピンと来ない場合はもう一度復習しておきましょう。
isinstanceでの型チェック
isinstance()関数は、オブジェクトが指定した型かどうかを真偽値（TrueまたはFalse）で返します。
次のような形で書きます。
isinstance(確認したい値, 型)
また、type()関数よりも柔軟な型チェックが可能で、継承関係も考慮してくれます。
継承とは、あるクラス（型の設計図のようなもの）が別のクラスの性質を引き継ぐ仕組みです。
例えば、bool型はint型を継承しているため、isinstance(True, int)はTrueを返します。このような関係性も自動的に判定してくれるのがisinstance()の便利な点です。

  
animal_name = "パンダ"
animal_count = 10

print(isinstance(animal_name, str))
print(isinstance(animal_count, (int, float)))
print(isinstance(animal_name, (int, list)))

  


  







出力結果
True
True
False
次のように、複数の型をタプルで指定して一度に確認することもできます。
isinstance(確認したい値, (型1, 型2, ...))
この書き方を理解した上で、上記のコード例を確認してみましょう。
3つの文は、次のような意味を持っています。
    

  1. isinstance(animal_name, str)で、animal_nameが文字列型かチェック → True
    2. 

  2. isinstance(animal_count, (int, float))で、animal_countが整数型または小数型かチェック → True
    3. 

  3. isinstance(animal_name, (int, list))で、animal_nameが整数型またはリスト型かチェック → False
    4. 

複数の型を指定する際は、どれかに合致した場合にTrueと判定されるということです。
型変換・強制（キャスト）の基本
型を変換するには、int()、float()、str()などの関数を使います。
ただし、変換できない値（文字列「ウマ」を数値にするなど）に対して実行しようとすると、エラーが発生するため注意が必要です。

  
age_text = "7"
weight_text = "4.5"

age_number = int(age_text)
weight_number = float(weight_text)

print(f"ネコの年齢: {age_number + 1}歳")
print(f"体重: {weight_number}kg")

  


  







出力結果
ネコの年齢: 8歳
体重: 4.5kg
このコード例では、文字列として保存されていた数値を、int()やfloat()を使って数値型に変換しています。変換後は計算ができるようになります。
Pythonの型ヒントと型チェック
型ヒントは、Python 3.5から導入された機能で、コードをより読みやすく、バグを見つけやすくする仕組みです。
Pythonは動的型付け言語なので、変数の型を書かなくても動きます。しかし、型ヒントを使うことで、「この変数には文字列が入ります」「この関数は数値を返します」といった情報を明示できます。
特に大きなプログラムやチーム開発では、この機能がとても役立つので覚えておきましょう。
型ヒントの基本構文と意味
型ヒントは、関数の引数や戻り値の型を明示的に書く方法です。
引数の型は「変数名: 型」のように書き、戻り値の型は「-> 型」のように書きます。型ヒントを書いても実際の動作は変わりませんが、コードを読む人にとって「どんなデータを扱うのか」が一目でわかるようになります。

  
def introduce_animal(name: str, age: int) -> str:
    return f"この動物は{name}で、{age}歳です"

result = introduce_animal("ウサギ", 2)
print(result)

  


  







出力結果
この動物はウサギで、2歳です
nameは文字列型（str）、ageは整数型（int）であることを示しています。
また、-> strで、この関数が文字列を返すことを表しています。
リストや辞書に対する型ヒントの指定方法
リストや辞書のような「中に別のデータが入る型」にも、型ヒントを使うことができます。
書き方は次のような形です。
    

  • list[str]: 文字列のリスト
    • 

  • dict[str, int]: 文字列をキー、整数を値とする辞書
    • 

これにより、リストや辞書の中身がどんな型なのかも明確に示すことができます。

  
def count_animals(animal_list: list[str]) -> dict[str, int]:
    result = {}
    for animal in animal_list:
        result[animal] = len(animal)
    return result

animals = ["ゾウ", "キリン", "サル"]
lengths = count_animals(animals)
print(lengths)

  


  







出力結果
{'ゾウ': 2, 'キリン': 3, 'サル': 2}
動作の流れを確認しましょう。
    

  1. count_animals関数に["ゾウ", "キリン", "サル"]というリストを渡す
    2. 

  2. 関数内で空の辞書resultを作成
    3. 

  3. リストの各動物名について、len()で文字数を数える
      

    • "ゾウ" → 2文字
      • 

    • "キリン" → 3文字
      • 

    • "サル" → 2文字
      • 

    

    4. 

  4. result[animal] = len(animal)で辞書に登録
      

    • result["ゾウ"] = 2 → 辞書に「ゾウ: 2」を追加
      • 

    • result["キリン"] = 3 → 辞書に「キリン: 3」を追加
      • 

    • result["サル"] = 2 → 辞書に「サル: 2」を追加
      • 

    

    5. 

  5. 完成した辞書{"ゾウ": 2, "キリン": 3, "サル": 2}を返す
    6. 

このコード例では、animal_list: list[str]で「文字列のリスト」を受け取り、-> dict[str, int]で「文字列と整数の辞書」を返すことを示していることが読み取れますね。
型ヒントを使うメリットと注意点
型ヒントを使うと、便利な点がいくつかあります。
まず、エディタやIDEが「この変数には文字列が入る」と理解できるため、コードを書くときの補完機能の向上につながります。また、mypyのようなツールを使えば、プログラムを実行する前に型の間違いを見つけることもできます。
さらに、他の人がコードを読むときにも理解しやすくなるというメリットもあります。

  
def calculate_age_in_months(age_years: int) -> int:
    return age_years * 12

dog_age = calculate_age_in_months(5)
print(f"イヌの年齢: {dog_age}ヶ月")

  


  







出力結果
イヌの年齢: 60ヶ月
型ヒントによって「引数も戻り値も整数」であることが明確になっています。
ただし、型ヒントはあくまで「ヒント」なので、実行時に型チェックはされません。間違った型を渡してもエラーにならないため、その点は認識しておきましょう。
型の定義と独自型の作成
Pythonでは、既存の型（整数、文字列、リストなど）だけでなく、自分で新しい型を作ることができます。
クラスを使って独自の型を定義すると、関連するデータと処理をまとめて管理するといったこともできるということです。
例えば、「動物」という型を作れば、名前や年齢といった情報と、鳴き声を出すといった動作を一つにまとめられます。
ここでは、クラスを使った独自型の作り方と活用方法を解説します。
クラスによる新しい型の定義
クラスを使うと、関連するデータと処理をまとめた独自の型を作成できます。
classキーワードでクラスを定義し、__init__メソッド（初期化メソッド）でデータの初期設定を行います。作成したクラスは、新しいデータ型として機能します。
実際の例を見てみましょう。

  
class Animal:
    def __init__(self, name: str, species: str):
        self.name = name
        self.species = species

    def introduce(self) -> str:
        return f"{self.species}の{self.name}です"

my_pet = Animal("ミケ", "ネコ")
print(my_pet.introduce())

  


  







出力結果
ネコのミケです
Animalという新しい型を作っています。
__init__で名前と種類を設定し、introduceメソッドで自己紹介する機能を持たせています。
my_pet = Animal("ミケ", "ネコ")で、この型を使って実際のデータ（オブジェクト）を作成しているという形です。
インスタンス化とasを使ったエイリアス的利用
作成したクラスから実際のデータ（オブジェクト）を作ることを「インスタンス化」と呼びます。
下記の説明で、クラスとオブジェクトのイメージをつかんでください。
    

  • 
クラス: 設計図や型枠のようなもの（例: 「動物」という概念の定義）
    • 

  • 
オブジェクト: クラスをもとに作られた実際のデータ（例: 「ポチという名前の犬」）
    • 

クラスという設計図から、具体的な値を持ったオブジェクトを作り出すのがインスタンス化です。1つのクラスから、異なる値を持つ複数のオブジェクトを作ることもできます。
ちなみに、長いクラス名を扱いやすくするために、import文とasキーワードを使って短い別名をつけることもできるので、頭の片隅に置いておきましょう。
ただし、ここでは基本的なインスタンス化の例を見ていきます。

  
class WildAnimal:
    def __init__(self, species: str, habitat: str):
        self.species = species
        self.habitat = habitat

    def info(self) -> str:
        return f"{self.species}は{self.habitat}に住んでいます"

tiger = WildAnimal("トラ", "ジャングル")
elephant = WildAnimal("ゾウ", "サバンナ")
print(tiger.info())

  


  







出力結果
トラはジャングルに住んでいます
WildAnimalというクラスからtigerとelephantという2つのオブジェクトを作っています。
同じクラスから作られていても、それぞれ異なるデータを持つことができるのです。
型ヒントと独自型を組み合わせた応用例
自分で定義したクラスを型ヒントとして使うことで、関数がどんな型のデータを扱うのかを明確に示すことができます。
これにより、コードを読む人が「この関数はどんなデータを受け取って、何を返すのか」を簡単に理解できるというメリットがあります。
特に大きなプログラムでは、この明確さはとても重要です。

  
class Pet:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

def care_for_pet(pet: Pet) -> str:
    return f"{pet.name}（{pet.age}歳）のお世話をしました"

def create_pet_list() -> list[Pet]:
    return [Pet("ポチ", 3), Pet("タマ", 5)]

pets = create_pet_list()
for pet in pets:
    print(care_for_pet(pet))

  


  







出力結果
ポチ（3歳）のお世話をしました
タマ（5歳）のお世話をしました
このプログラムでは、care_for_pet関数がPet型のデータを受け取ることを型ヒント（pet: Pet）で示しています。
また、create_pet_list関数がPet型のリストを返すことも明示しています（-> list[Pet]）。
このように、独自に作った型と型ヒントを組み合わせることで、よりわかりやすいコードが書けます。
よくある質問（Q&A）
Q: 文字列と数値を足し算できますか？ 
A: いいえ、Pythonでは異なる型同士の足し算は基本的にできません。str()やint()で型を合わせる必要があります。

  
number = 5
text = "匹"
result = str(number) + text
print(result)

  


  







出力結果
5匹
Q: リストとタプルの使い分け方は？ 
A: 変更が必要な場合はリスト、変更しない固定データにはタプルを使いましょう。タプルの方がメモリ効率も良くなります。
Q: 型ヒントは必ず書く必要がありますか？ 
A: 必須ではありませんが、書くことでコードが読みやすくなり、IDE支援も受けられるため推奨されます。
Q: 辞書のキーに使える型は？ 
A: 文字列、数値、タプルなどイミュータブル（変更不可能）な型のみ使用できます。リストは使用できません。
Q: 動的型付けの欠点はありますか？ 
A: 実行時まで型エラーが発見できない場合があります。型ヒントや適切なテストで対処することが大切です。
まとめ
Pythonの型は、プログラムで扱うデータの種類や性質を表す重要な概念です。
この記事では、型の基本概念から実用的な活用方法まで解説しました。
型の活用場面について、確認しておきましょう。
型が活躍する場面
    

  • データの種類（数値、文字列、リストなど）を適切に使い分けたいとき
    • 

  • 関数の引数や戻り値の型を明確にして、バグを防ぎたいとき
    • 

  • リストや辞書を使って、複数のデータをまとめて管理したいとき
    • 

  • 独自のクラスを作って、関連するデータと処理を一つにまとめたいとき
    • 

型を使う上で押さえておきたいポイントは、次の通りです。
重要なポイント
    

  • Pythonは動的型付け言語なので、型宣言が不要
    • 

  • int・float・str・boolなど基本型の特徴
    • 

  • リスト・辞書などによる効率的なデータ管理
    • 

  • type関数やisinstance関数の使い方と役割
    • 

  • 型ヒントを活用すると、コードの可読性と保守性が向上すること
    • 

初めて型を学ぶ方も、この記事で紹介した基本的な使い方と実用例を参考に、実際にコードを書いてみてください。
型の概念をしっかりと理解できると、Pythonのスキルの基礎が固まります。データの性質に応じて適切な型を選択し、型ヒントを活用してより良いコードが書けるようになりましょう。
レベルを更に上げたい方はpaizaプログラミングスキルチェックへ





























  1. paizaラーニングトップ
  2. ナレッジ
  3. Pythonのナレッジ記事一覧
  4. Pythonのデータ型を徹底攻略！型の種類から型ヒントまで詳しく解説