データサイエンティストが知るべき Python の必須概念 5 つ

image**

# イントロダクション

データサイエンスのために Python を使うのは「みんながそうしているから」という理由だけで行うべきではありません。データ分野における Python の支配的地位は偶然によるものではありません。これは、低レベルのメモリ管理を抽象化し、非常に表現力豊かで可読性の高い構文に基づいて構築された言語です。しかし、この同じ高レベルな抽象化には代償が伴います：標準的な Python の実行は動的型付けでありインタプリタ型であるため、生来の反復処理（ループ）が非常に遅くなることがあります。

高性能なデータシステムを記述するためには、データサイエンティストは標準的な手続き型コーディングパターンから、専門化されたベクトル化（vectorization）およびメモリ意識型のアプローチへとシフトする必要があります。本記事では、ぎこちなく遅いスパゲッティコードの記述から、瞬時に高速で生産環境対応かつ美しく機能的なデータパイプラインの構築へと移行するための、知っておくべき 5 つの Python の概念を深く掘り下げていきます。

# 1. NumPy ベクトル化

標準的な Python のループは遅いです。Python はインタプリタ型言語であるため、for ループの各反復には大きなオーバーヘッドが伴います：型チェック、動的メソッドルックアップ、参照カウントなどです。数百万ものデータポイントを処理する際、これらのマイクロオーバーヘッドのコストは累積し、数秒単位のボトルネックへと発展します。

解決策は NumPy のベクトル化です。Python バイトコード内で要素を逐次処理するのではなく、NumPy はループを高度に最適化された事前コンパイル済みの C 拡張機能にオフロードします。これらの操作は配列全体に対して一度に行われ、機械レベルで連続した配列ブロックを実行し、しばしば単一命令多重データ (SIMD) 命令を利用します。

// 面倒な方法

100 万個の浮動小数点値からなるリストがあり、各読み取り値を 1.5 倍して 10.0 の較正定数を適用する必要があるとしましょう。反復的な Python ループを使用する場合:

import time

1000 万個のセンサー読み取り値を持つ大きなリスト

n_elements = 10_000_000

data_list = [float(x) for x in range(n_elements)]

明示的な Python ループによる値のスケーリング

start_time = time.time()

scaled_list = []

for val in data_list:

scaled_list.append(val * 1.5 + 10.0)

loop_duration = time.time() - start_time

print(f"Loop implementation took: {loop_duration:.6f} seconds")

出力:

Loop implementation took: 0.378866 seconds

// ベクトル化された方法

ここでは、エレガントなベクトル化された代替案を示します。データを連続した NumPy 配列に読み込み、配列オブジェクトに対して直接演算を行います:

import numpy as np

import time

1000 万個のセンサー読み取り値を持つ大きなリスト

n_elements = 10_000_000

ベクトル化された方法: NumPy は事前コンパイル済みの C ループで計算全体を実行します

data_array = np.arange(n_elements, dtype=float)

start_time = time.time()

scaled_array = data_array * 1.5 + 10.0

numpy_duration = time.time() - start_time

print(f"NumPy implementation took: {numpy_duration:.6f} seconds")

print(f"Speedup: {loop_duration / numpy_duration:.1f}x faster!")

Output:

Loop implementation took: 0.348456 seconds

NumPy implementation took: 0.013395 seconds

Speedup: 26.0x faster!

By vectorizing the arithmetic, we can achieve a massive performance boost with cleaner, more concise code. The loop is eliminated from Python space and executed entirely in high-speed C space.

# 2. Broadcasting: Math Rules for Mismatched Dimensions

In linear algebra, matrix operations generally require both operands to have the exact same shape. However, in data science, we often need to perform operations on arrays of differing dimensions, such as subtracting feature column averages from a dataset, or normalizing row values.

Rather than duplicating data to force matching shapes, NumPy uses a set of mathematical rules called broadcasting. Broadcasting allows element-wise operations on arrays of different shapes by virtually expanding the smaller array along the missing or single-element dimensions, without copying any data in memory.

The broadcasting rules are:

• アレイのランク（次元数）が一致しない場合、低いランクのアレイの形状に 1 を先頭に追加し、両方の形状の長さが等しくなるまで繰り返します
• 2 つの次元は、互いに等しいか、いずれかが 1 の場合に互換性があるとみなされます
• 互換性がある場合、アレイはサイズが 1 の次元に沿って引き伸ばされたものとして振る舞い、もう一方のアレイの形状に一致します

// 面倒なやり方

3x4 の特徴量行列（3 サンプル、4 特徴）があり、各列の平均値を引いて特徴量を「中心化」したいとしましょう。

import numpy as np

features = np.array([

[10.0, 20.0, 30.0, 4.0],

[12.0, 24.0, 36.0, 8.0],

[14.0, 28.0, 42.0, 12.0]

])

各特徴量列の平均値（形状：(4,)）

col_means = np.mean(features, axis=0)

ネストされたループを使用して手動で中心化

mean_demeaned_clunky = np.zeros_like(features)

for idx in range(features.shape[0]):

for col_idx in range(features.shape[1]):

mean_demeaned_clunky[idx, col_idx] = features[idx, col_idx] - col_means[col_idx]

別解：アレイをタイル状に並べて形状を強制的に一致させる

tiled_means = np.tile(col_means, (features.shape[0], 1))

demeaned_tiled = features - tiled_means

// Pythonic なやり方

ブロードキャスト（broadcasting）を使用すれば、引き算を直接実行できます。NumPy は自動的に (3, 4) の特徴量行列と (4,) の列平均アレイを整合させ、列平均の形状を (1, 4) とみなして処理します。

import numpy as np

features = np.array([

[10.0, 20.0, 30.0, 4.0],

[12.0, 24.0, 36.0, 8.0],

[14.0, 28.0, 42.0, 12.0]

])

col_means = np.mean(features, axis=0)

Pythonic subtraction via automatic broadcasting

demeaned_broadcasting = features - col_means

Dividing each row by its row sum

row_sums has shape (3,) -> to divide (3, 4) by (3,), we expand shape to (3, 1) using np.newaxis

row_sums = np.sum(features, axis=1)

normalized_features = features / row_sums[:, np.newaxis]

print("Demeaned:\n", demeaned_broadcasting)

print("\nNormalized Rows:\n", normalized_features)

Output:

Demeaned:

[[-2. -4. -6. -4.]

[ 0. 0. 0. 0.]

[ 2. 4. 6. 4.]]

Normalized Rows:

[[0.15625 0.3125 0.46875 0.0625 ]

[0.15 0.3 0.45 0.1 ]

[0.14583333 0.29166667 0.4375 0.125 ]]

Broadcasting eliminates duplicate values and memory copying. Under the hood, NumPy runs the subtraction loops at C speed without creating a tiled intermediate matrix, preserving memory bandwidth and accelerating operations.

# 3. The Pandas .pipe() and .assign() Methods: Clean, Functional Pipelines

Data preparation in Pandas often degenerates into sequential spaghetti code. Developers create multiple intermediate DataFrames (df1, df2, etc.), modify variables in-place, or chain brackets. This leads to code that is difficult to read, hard to test, and notoriously prone to the dreaded SettingWithCopyWarning.

Modern Pandas は、手続き型の書き換えから、機能的かつ宣言的なデータパイプラインへの移行を推奨しています。特徴量の作成には .assign() を、再利用可能な複数カラム操作には .pipe() を活用することで、単一のパイプライン内でステップを連鎖させることが可能になります。

// 面倒なやり方

外れ値のフィルタリング、文字列の標準化、欠損値の補完、売上税の計算が必要となる生のカスタマー販売データを例に取ってみましょう。

import pandas as pd

import numpy as np

raw_data = {

'Customer_ID': [101, 102, 103, 104, 105],

'Age': [25, -5, 47, 120, 31],

'Country': ['usa', 'CANADA', 'usa', 'Germany', 'canada'],

'Raw_Spend': [120.50, 450.00, 80.00, np.nan, 300.00]

}

df = pd.DataFrame(raw_data)

逐次的な中間書き換え

df_clean = df.copy()

1. 無効な年齢を除外

df_clean = df_clean[(df_clean['Age'] >= 0) & (df_clean['Age'] <= 100)]

2. カントリー名の標準化（コピー警告のリスクあり）

df_clean['Country'] = df_clean['Country'].str.upper().str.strip()

3. Raw_Spend の欠損値を補完

median_spend = df_clean['Raw_Spend'].median()

df_clean['Raw_Spend'] = df_clean['Raw_Spend'].fillna(median_spend)

4. 課税済み支出の計算

df_clean['Taxed_Spend'] = df_clean['Raw_Spend'] * 1.15

5. カラム名のフォーマット

df_clean = df_clean.rename(columns={'Customer_ID': 'customer_id'})

// Pythonic なやり方

これを関数型メソッドチェーンの問題として捉えれば、国の標準化ステップを再利用可能なユーティリティ関数にラップし、単一のクリーンで自己完結型のパイプラインを構築できます。

import pandas as pd

import numpy as np

raw_data = {

'Customer_ID': [101, 102, 103, 104, 105],

'Age': [25, -5, 47, 120, 31],

'Country': ['usa', 'CANADA', 'usa', 'Germany', 'canada'],

'Raw_Spend': [120.50, 450.00, 80.00, np.nan, 300.00]

}

df = pd.DataFrame(raw_data)

.pipe() 用の再利用可能なカスタム変換関数

def standardize_countries(dataframe: pd.DataFrame) -> pd.DataFrame:

df_out = dataframe.copy()

df_out['Country'] = df_out['Country'].str.upper().str.strip()

return df_out

単一のエレガントな関数型パイプライン

df_clean_pipeline = (

df.query("Age >= 0 and Age <= 100")

.assign(

Raw_Spend=lambda x: x['Raw_Spend'].fillna(x['Raw_Spend'].median()),

Taxed_Spend=lambda x: x['Raw_Spend'] * 1.15

)

.pipe(standardize_countries)

.rename(columns={'Customer_ID': 'customer_id'})

)

print(df_clean_pipeline)

出力:

customer_id Age Country Raw_Spend Taxed_Spend

0 101 25 USA 120.5 138.5750

2 103 47 USA 80.0 92.0000

4 105 31 CANADA 300.0 345.0000

メソッドチェーンを使用すると、元の DataFrame の状態が誤って変更されることを防ぎ、副作用を回避できます。.assign() はラムダ関数を受け取って列の割り当てを処理し、その中で x はチェーン内のその時点での DataFrame のアクティブな状態を指します。一方、.pipe() を使用すると、カスタム操作をきれいにモジュール化することができます。

# 4. データ変換のためのラムダ関数

特徴量エンジニアリングでは、文字列のフォーマット、値の分割、条件文の適用など、小規模で単一目的の変換が頻繁に求められます。これらの単純な計算のためにカスタム名付き関数（def を使用）を作成すると、スクリプトに不要なボイラープレートコードを追加することになります。

よりエレガントなアプローチは、Pandas の .map() や .apply() 内で ラムダ関数 を使用することです。ラムダ関数は名前を持たない、その場で定義される捨てられる関数であり、迅速なデータマッピングやクリーンなインライン変換に最適です。

// 面倒な方法

従業員データのセットがあり、リモートワークの状態をマッピングして姓を解析する必要があるとしましょう。よくある間違いは、手動のループを書くか iterrows() を利用することです:

import pandas as pd

df = pd.DataFrame({

'employee_name': ['john doe', 'jane smith', 'bob johnson'],

'department_code': ['IT_01', 'HR_02', 'IT_03'],

'is_remote': [1, 0, 1]

})

Row-by-row iteration (slow and verbosely managed)

df_clunky = df.copy()

df_clunky['remote_status'] = None

df_clunky['last_name'] = None

for index, row in df_clunky.iterrows():

# Parsing remote status

if row['is_remote'] == 1:

df_clunky.at[index, 'remote_status'] = "Remote"

else:

df_clunky.at[index, 'remote_status'] = "Office"

# Parsing and capitalizing last name

name_parts = row['employee_name'].split()

df_clunky.at[index, 'last_name'] = name_parts[1].capitalize()

// The Pythonic Way

Here is the clean, declarative approach using inline lambda transformations. We apply inline anonymous logic to transform columns instantly using .map() for simple conversions and .apply() for custom string operations:

import pandas as pd

df = pd.DataFrame({

'employee_name': ['john doe', 'jane smith', 'bob johnson'],

'department_code': ['IT_01', 'HR_02', 'IT_03'],

'is_remote': [1, 0, 1]

})

Lambdas nested inside map() and apply()

df_opt = df.assign(

remote_status=lambda d: d['is_remote'].map(lambda val: "Remote" if val == 1 else "Office"),

last_name=lambda d: d['employee_name'].apply(lambda name: name.split()[-1].capitalize()),

dept_level=lambda d: d['department_code'].apply(lambda code: code.split('_')[-1])

)

print(df_opt[['employee_name', 'last_name', 'remote_status', 'dept_level']])

Output:

employee_name last_name remote_status dept_level

0 john doe Doe Remote 01

1 jane smith Smith Office 02

2 bob johnson Johnson Remote 03

ラムダ関数を使用することで、ロジックを列作成文に密接に結びつけた自己完結型のトランスフォーム記述が可能になります。ラムダ関数を .map() や .apply() と組み合わせることで、冗長なネストされたループを排除し、コードを見やすく美しく保つことができます。

# 5. データフレームによるメモリ管理：データ型（dtypes）の最適化

デフォルトでは、Pandas がデータセット（CSV ファイルやデータベースファイルなど）を読み込む際、安全策を取ります。整数は 64 ビット (int64) として、小数は 64 ビット (float64) として、テキスト列は汎用のオブジェクト型として読み込まれます。これは安全な方法ですが、結果として最大限のメモリ使用量（メモリーフットプリント）を招きます。数十万行程度のデータセットでも、システム RAM を瞬時にギガバイト単位で消費し、ローカル環境での動作遅延や、本番サーバーにおける「メモリ不足 (out of memory)」エラーを引き起こす可能性があります。

数値列をより小さな整数/浮動小数点数にダウキャスト（型変換）し、低多様性のテキスト列を category データ型に変換することで、データフレームのメモリ使用量を劇的に削減できます。

例えば、年齢列の値は 0 から 100 の範囲にあり、これは標準的な 64 ビット (int64) データ型ではなく、単一の 8 ビット整数 (int8。最大 127 の値を保持可能) に容易に収まります。同様に、カテゴリ値は内部でテキスト文字列を単純な整数コードにマッピングするため、大幅なメモリ節約効果をもたらします。

// 面倒な方法

10 万人のユーザーからなる合成サブスクライバーデータセットを生成し、デフォルトの Pandas タイプが消費するメモリを見てみましょう:

import pandas as pd

import numpy as np

n_rows = 100_000

np.random.seed(42)

df_large = pd.DataFrame({

'user_id': np.random.randint(1000000, 1000000 + n_rows, size=n_rows),

'age': np.random.randint(18, 90, size=n_rows),

'device_type': np.random.choice(['iOS', 'Android', 'Web', 'SmartTV'], size=n_rows),

'monthly_revenue': np.random.uniform(5.0, 150.0, size=n_rows),

'active_subscriber': np.random.choice([0, 1], size=n_rows)

})

メモリ使用状況の調査

print(df_large.info(memory_usage='deep'))

memory_before = df_large.memory_usage(deep=True).sum() / (1024 ** 2)

print(f"Default Memory Usage: {memory_before:.2f} MB")

出力:

<class 'pandas.core.frame.DataFrame'>

RangeIndex: 100000 entries, 0 to 99999

Data columns (total 5 columns):

# Column Non-Null Count Dtype

--- ------ -------------- -----

0 user_id 100000 non-null int64

1 age 100000 non-null int64

2 device_type 100000 non-null object

3 monthly_revenue 100000 non-null float64

4 active_subscriber 100000 non-null int64

dtypes: float64(1), int64(3), object(1)

memory usage: 8.2 MB

None

Default Memory Usage: 8.20 MB

// The Pythonic Way

Now let's apply our optimizations: casting columns to their minimum required numeric bounds and converting text columns to category:

Downcasting types

df_optimized = df_large.assign(

user_id=df_large['user_id'].astype('int32'), # Max 1.1 million fits in int32

age=df_large['age'].astype('int8'), # Max age 90 fits in int8

device_type=df_large['device_type'].astype('category'), # Low cardinality (4 unique strings)

monthly_revenue=df_large['monthly_revenue'].astype('float32'), # Single precision float is plenty

active_subscriber=df_large['active_subscriber'].astype('int8') # Binary flag fits in int8

)

Inspecting optimized memory usage

print(df_optimized.info(memory_usage='deep'))

memory_after = df_optimized.memory_usage(deep=True).sum() / (1024 ** 2)

print(f"Optimized Memory Usage: {memory_after:.2f} MB")

print(f"Memory Footprint Reduction: {((memory_before - memory_after) / memory_before) * 100:.1f}%")

Output:

memory usage: 1.0 MB

None

Optimized Memory Usage: 1.05 MB

Memory Footprint Reduction: 87.2%

単に列のデータ型（dtypes）を調整しただけで、DataFrame のサイズを約 90% も削減できました**！低カルディナリティの文字列に対して category を使用することで、Pandas は行間で文字列を重複させるのではなく、各行を軽量な整数インデックスにマッピングします。

# まとめ

**

これら 5 つの基本的な Python の概念をマスターすることは、効率的で読みやすく、高度に最適化されたデータパイプラインを設計するシニアデータサイエンティストになるための重要な一歩です。

NumPy のベクトル化（vectorization）とブロードキャスト（broadcasting）を活用することで、生来の Python ループを排除し、ハードウェアレベルの高速化を実現できます。.pipe() や .assign() を用いた関数型 Pandas パイプラインへ移行することで、特徴量エンジニアリングワークフローの可読性と安全性が向上します。これらに、オンザフライ変換のためのインラインラムダ関数（lambda functions）と、データ型（dtypes）を通じた積極的なメモリ管理を組み合わせることで、アルゴリズムをローカルプロトタイプから大規模な本番環境ワークロードまでシームレスにスケールさせることが可能になります。

データサイエンスは数学であると同時にソフトウェアエンジニアリングでもあります。コードを第一級の製品として扱いましょう。そうすれば、データの処理が高速化され、パイプラインの障害が減り、システム構築が楽しくなります。

本シリーズの前回記事もぜひご覧ください：

• 5 つの必須 Python 概念
• さらに知るべき 5 つの Python 概念

Matthew Mayo** (@mattmayo13) は、コンピュータサイエンスの修士号とデータマイニングの大学院ディプロマを取得しています。KDnuggets と Statology の編集長、および Machine Learning Mastery の寄稿編集者として、Matthew は複雑なデータサイエンスの概念を誰もが理解できるようにすることを目的としています。彼の専門的な関心分野には、自然言語処理、言語モデル、機械学習アルゴリズム、そして新興 AI の探求が含まれます。彼はデータサイエンスコミュニティにおける知識の民主化という使命に駆り立てられています。Matthew は 6 歳の頃からコーディングを続けています。