0Pricing
Pandas & NumPy Academy · 강의

열 데이터 형식 확인하기

dtypes 속성을 읽고 int64, float64, object를 구분하며 변환이 필요한 열을 찾아냅니다.

열 데이터 형식 확인하기은(는) CoddyKit의 무료 Pandas & NumPy Academy 강의입니다. 이것은 4개 중 1번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Pandas & NumPy Academy 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Pandas & NumPy Academy 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

Why Column Data Types Matter

Every column in a Pandas DataFrame has a dtype (data type) that determines how values are stored in memory and which operations are valid on them. An integer column with dtype object (string) cannot be summed. A date stored as a string is treated as text, not a time series. Incorrect dtypes are one of the most common causes of silent bugs and unexpected results in data analysis pipelines.

Always inspect dtypes as the very first step after loading a new dataset.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'age': ['25', '30', '35'],      # looks like int, stored as object
    'salary': [50000, 60000, 70000], # int64
    'hired': ['2022-01-01', '2023-06-15', '2024-03-10']  # looks like date
})

print(df.dtypes)
# age       object
# salary     int64
# hired     object
# dtype: object

The dtypes Attribute

DataFrame.dtypes returns a Series whose index is the column names and whose values are the Pandas dtype of each column. Common dtypes you will encounter are int64, float64, object (strings and mixed), bool, datetime64[ns], and category. The dtype name tells you both the kind of data and how many bytes each value uses.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'int_col': [1, 2, 3],
    'float_col': [1.5, 2.5, 3.5],
    'str_col': ['a', 'b', 'c'],
    'bool_col': [True, False, True]
})

print(df.dtypes)
# int_col      int64
# float_col  float64
# str_col     object
# bool_col      bool
# dtype: object

Identifying the object Dtype

The object dtype is Pandas' catch-all for columns that cannot be stored as a numeric or boolean type. It typically means string data, but it can also indicate a mixed-type column (e.g., integers mixed with strings). Object columns consume more memory than specialised dtypes and are slower to operate on. When you see object, ask: should this be a string, a number, a category, or a date?

import pandas as pd

df = pd.DataFrame({'mixed': [1, 'two', 3.0, None]})
print(df.dtypes)
# mixed    object

# Check actual Python types inside the column
print(df['mixed'].apply(type).value_counts())
# <class 'int'>      1
# <class 'str'>      1
# <class 'float'>    2  (includes NaN which is float)

info() for a Complete Type Overview

df.info() prints a concise table showing every column's name, non-null count, and dtype, plus total memory usage. This one command gives you a complete snapshot of dataset quality: you can see which columns have missing data and which have wrong dtypes at the same time, making it the standard first command after loading a dataset.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'id': [1, 2, 3],
    'score': [88.5, 92.0, np.nan],
    'grade': ['A', 'A', 'B']
})

df.info()
# <class 'pandas.core.frame.DataFrame'>
# RangeIndex: 3 entries, 0 to 2
# Data columns (total 3 columns):
#  #   Column  Non-Null Count  Dtype
# ---  ------  --------------  -----
#  0   id      3 non-null      int64
#  1   score   2 non-null      float64
#  2   grade   3 non-null      object
# dtypes: float64(1), int64(1), object(1)
# memory usage: 200.0+ bytes

Common dtype Problems After read_csv

When Pandas reads a CSV file, it infers dtypes by scanning values. Several common problems arise: numeric columns read as object if there are comma-thousand-separators or currency symbols; boolean columns read as object if stored as 'Yes'/'No' strings; and date columns read as object because Pandas doesn't parse dates unless told to. Recognising these patterns lets you fix them quickly with type conversion.

import pandas as pd
import io

csv = '''price,date,is_active
'1,200',2024-01-15,Yes
'800',2024-02-20,No
'''

df = pd.read_csv(io.StringIO(csv))
print(df.dtypes)
# price       object    <- should be int
# date        object    <- should be datetime64
# is_active   object    <- should be bool

Memory Usage of Different dtypes

Different dtypes consume vastly different amounts of memory. An int64 column uses 8 bytes per value, while an object column storing short strings may use 50-200 bytes per value. For DataFrames with millions of rows, choosing the right dtype can reduce memory from gigabytes to megabytes. Call df.memory_usage(deep=True) to see the byte cost per column.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'int64_col': np.arange(1_000_000, dtype='int64'),
    'float32_col': np.arange(1_000_000, dtype='float32'),
    'obj_col': ['a'] * 1_000_000
})

mem = df.memory_usage(deep=True) / 1024**2  # MB
print(mem.round(2))
# Index         0.00
# int64_col     7.63
# float32_col   3.81
# obj_col      55.26  <- much more for object!

Spotting Wrong-Typed Numeric Columns

A common issue is a numeric column stored as object because of stray formatting characters. You can detect this by checking if pd.to_numeric(df['col'], errors='coerce') produces a different result than the original column. Any values that cannot be parsed become NaN, revealing exactly which rows caused the type inference to fail.

import pandas as pd

df = pd.DataFrame({'revenue': ['1000', '2000', '$3000', '4,000']})

# Check which values can't be parsed as numbers
parsed = pd.to_numeric(df['revenue'], errors='coerce')
print(parsed)
# 0    1000.0
# 1    2000.0
# 2       NaN   <- '$3000' failed
# 3       NaN   <- '4,000' failed

Checking for Integer vs Float Ambiguity

When a column has any NaN values, Pandas stores integer columns as float64 because the standard NumPy integer types cannot represent NaN. The resulting floats like 25.0 look like integers but are stored as floats. Pandas introduced nullable integer types (Int64 with capital I) that support NaN while maintaining integer semantics.

import pandas as pd
import numpy as np

df = pd.DataFrame({'count': [1, 2, np.nan, 4]})
print(df['count'].dtype)  # float64 — because NaN is float

# Nullable integer type supports NaN
df['count'] = df['count'].astype('Int64')  # capital I!
print(df)
#    count
# 0      1
# 1      2
# 2   <NA>
# 3      4
print(df['count'].dtype)  # Int64

select_dtypes() for Type-Based Filtering

df.select_dtypes(include=) lets you select all columns of a particular type family. Common arguments: 'number' (all numeric), 'object' (strings), 'bool', 'datetime', 'category'. This is very useful at the start of a pipeline to apply numeric cleaning only to numeric columns and string cleaning only to text columns.

import pandas as pd

df = pd.DataFrame({
    'name': ['Alice', 'Bob'],
    'age': [25, 30],
    'salary': [50000.0, 70000.0],
    'dept': ['Eng', 'HR']
})

numeric = df.select_dtypes(include='number')
print('Numeric columns:', numeric.columns.tolist())
# ['age', 'salary']

text = df.select_dtypes(include='object')
print('Text columns:', text.columns.tolist())
# ['name', 'dept']

Building a dtype Report

A practical EDA habit is building a dtype report that lists each column's dtype, unique value count, and sample values. This helps you quickly identify columns that need conversion before analysis begins. You can generate such a report with a simple DataFrame constructed from column-wise aggregations.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'age': [25, 30, 35],
    'salary': [50000, 60000, 70000],
    'dept': ['Eng', 'HR', 'Eng'],
    'hired': ['2022-01-01', '2023-06-15', '2024-03-10']
})

report = pd.DataFrame({
    'dtype': df.dtypes,
    'unique_count': df.nunique(),
    'sample': df.iloc[0]
})
print(report)

Dtype Consistency in Production Pipelines

In production pipelines that process new data every day, dtypes can drift — a column that was always int64 might arrive as float64 if a single NaN appears. Add dtype assertions at the start of the pipeline to catch schema changes early. Failing loudly with a clear error is far better than silently producing wrong results downstream.

import pandas as pd

df = pd.DataFrame({'user_id': [1, 2, 3], 'score': [88.0, 92.0, 76.0]})

expected_dtypes = {'user_id': 'int64', 'score': 'float64'}

for col, expected in expected_dtypes.items():
    actual = str(df[col].dtype)
    assert actual == expected, (
        f'Column {col}: expected {expected}, got {actual}'
    )
print('All dtypes are correct')

Quick Check

Test your understanding of inspecting column data types.

Lesson Recap

In this lesson you learned: df.dtypes shows each column's type, object dtype is the catch-all for strings and mixed types, and df.info() gives a complete type+nullability overview. Use select_dtypes() to filter columns by type family and add dtype assertions to detect schema drift in production. Next up we convert columns to the correct dtypes using astype().

자주 묻는 질문

“열 데이터 형식 확인하기” 강의는 무료인가요?

네 — “열 데이터 형식 확인하기” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Pandas & NumPy Academy 강의 전체를 잠금 해제할 수 있습니다. Pandas & NumPy Academy 강의에는 총 4개의 강의가 포함되어 있습니다.

“열 데이터 형식 확인하기”에서 뭘 배우나요?

dtypes 속성을 읽고 int64, float64, object를 구분하며 변환이 필요한 열을 찾아냅니다. 브라우저에서 직접 실행하는 실습 코드로 Pandas & NumPy Academy을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

Pandas & NumPy Academy을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 Pandas & NumPy Academy은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 1번째 강의입니다.

“열 데이터 형식 확인하기” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 Pandas & NumPy Academy 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 Pandas & NumPy Academy 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

  1. 열 데이터 형식 확인하기
  2. astype()으로 형 변환하기
  3. 범주형 데이터 형식
  4. 날짜 올바르게 파싱하기
← Pandas & NumPy Academy(으)로 돌아가기