Memeriksa Jenis Data Lajur
Baca atribut dtypes, bezakan int64 daripada float64 dan object, serta kenal pasti lajur yang memerlukan penukaran.
Memeriksa Jenis Data Lajur ialah pelajaran Pandas & NumPy Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Pandas & NumPy Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Pandas & NumPy Academy merangkumi sejumlah 4 pelajaran.
Mengapa Jenis Data Lajur Penting
Setiap lajur dalam Pandas DataFrame mempunyai jenis data (jenis data) yang menentukan cara nilai disimpan dalam memori dan operasi yang sah terhadapnya. Lajur integer dengan jenis data object (rentetan) tidak boleh dijumlahkan. Tarikh yang disimpan sebagai rentetan akan dianggap sebagai teks, bukan siri masa. Jenis data yang tidak betul merupakan antara punca paling biasa bagi pepijat senyap dan hasil yang tidak dijangka dalam saluran paip analisis data.
Sentiasa periksa jenis data sebagai langkah pertama selepas memuatkan set data baharu.
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: objectAtribut jenis data
DataFrame.dtypes mengembalikan Series yang indeksnya ialah nama lajur dan nilainya ialah jenis data Pandas bagi setiap lajur. Jenis data biasa yang akan anda temui ialah int64, float64, object (rentetan dan data bercampur), bool, datetime64[ns] dan category. Nama jenis data memberitahu anda jenis data serta jumlah bait yang digunakan oleh setiap nilai.
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: objectMengenal pasti jenis data object
Jenis data object ialah pilihan umum Pandas untuk lajur yang tidak boleh disimpan sebagai jenis angka atau boolean. Biasanya ini bermaksud data rentetan, tetapi ia juga boleh menunjukkan lajur dengan jenis bercampur (contohnya, integer bercampur dengan rentetan). Lajur object menggunakan lebih banyak memori berbanding jenis data khusus dan lebih lambat diproses. Apabila anda melihat object, tanyakan: adakah ini sepatutnya rentetan, nombor, kategori atau tarikh?
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() untuk gambaran keseluruhan jenis yang lengkap
df.info() mencetak jadual ringkas yang menunjukkan nama setiap lajur, bilangan nilai bukan null dan jenis datanya, serta jumlah penggunaan memori. Satu arahan ini memberikan gambaran lengkap tentang kualiti set data: anda boleh melihat lajur yang mempunyai data hilang dan lajur yang mempunyai jenis data tidak betul pada masa yang sama. Oleh itu, arahan ini menjadi arahan pertama yang lazim digunakan selepas memuatkan set data.
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+ bytesMasalah jenis data yang biasa selepas read_csv
Apabila Pandas membaca fail CSV, ia menganggar jenis data dengan mengimbas nilai. Beberapa masalah biasa boleh berlaku: lajur angka dibaca sebagai object jika terdapat pemisah ribuan berbentuk koma atau simbol mata wang; lajur boolean dibaca sebagai object jika disimpan sebagai rentetan 'Yes'/'No'; dan lajur tarikh dibaca sebagai object kerana Pandas tidak menghuraikan tarikh melainkan diarahkan berbuat demikian. Dengan mengenali corak ini, anda boleh membetulkannya dengan cepat melalui penukaran jenis.
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 boolPenggunaan memori bagi jenis data yang berbeza
Jenis data yang berbeza menggunakan jumlah memori yang sangat berbeza. Lajur int64 menggunakan 8 bait bagi setiap nilai, manakala lajur object yang menyimpan rentetan pendek mungkin menggunakan 50-200 bait bagi setiap nilai. Bagi DataFrames dengan berjuta-juta baris, pemilihan jenis data yang betul boleh mengurangkan penggunaan memori daripada gigabait kepada megabait. Panggil df.memory_usage(deep=True) untuk melihat kos bait bagi setiap lajur.
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!Mengesan lajur angka dengan jenis yang salah
Masalah yang biasa berlaku ialah lajur angka disimpan sebagai object disebabkan aksara pemformatan yang terselit. Anda boleh mengesannya dengan memeriksa sama ada pd.to_numeric(df['col'], errors='coerce') menghasilkan keputusan yang berbeza daripada lajur asal. Sebarang nilai yang tidak boleh dihuraikan akan menjadi NaN, sekali gus menunjukkan dengan tepat baris yang menyebabkan penganggaran jenis gagal.
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' failedMemeriksa kekeliruan antara integer dan float
Apabila sesebuah lajur mempunyai sebarang nilai NaN, Pandas menyimpan lajur integer sebagai float64 kerana jenis integer NumPy standard tidak dapat mewakili NaN. Float yang terhasil seperti 25.0 kelihatan seperti integer tetapi sebenarnya disimpan sebagai float. Pandas memperkenalkan jenis integer yang menyokong nilai kosong (Int64 dengan I besar) yang menyokong NaN sambil mengekalkan ciri integer.
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) # Int64select_dtypes() untuk penapisan berasaskan jenis
df.select_dtypes(include=) membolehkan anda memilih semua lajur daripada keluarga jenis tertentu. Argumen biasa ialah: 'number' (semua jenis angka), 'object' (rentetan), 'bool', 'datetime' dan 'category'. Ini sangat berguna pada permulaan saluran paip untuk menggunakan pembersihan angka hanya pada lajur angka dan pembersihan rentetan hanya pada lajur teks.
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']Membina laporan jenis data
Amalan EDA yang berguna ialah membina laporan jenis data yang menyenaraikan jenis data setiap lajur, bilangan nilai unik dan beberapa nilai contoh. Ini membantu anda mengenal pasti dengan cepat lajur yang perlu ditukar sebelum analisis bermula. Anda boleh menjana laporan sedemikian dengan membina DataFrame ringkas daripada pengagregatan mengikut lajur.
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)Konsistensi jenis data dalam saluran paip pengeluaran
Dalam saluran paip pengeluaran yang memproses data baharu setiap hari, jenis data boleh berubah secara beransur-ansur — lajur yang sentiasa int64 mungkin tiba sebagai float64 jika satu nilai NaN muncul. Tambahkan pengesahan jenis data pada permulaan saluran paip untuk mengesan perubahan skema lebih awal. Menghentikan proses dengan jelas dan memaparkan ralat yang terang jauh lebih baik daripada menghasilkan keputusan yang salah secara senyap pada langkah seterusnya.
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')Semakan pantas
Uji pemahaman anda tentang pemeriksaan jenis data lajur.
Ulang kaji pelajaran
Dalam pelajaran ini, anda telah mempelajari bahawa: df.dtypes menunjukkan jenis setiap lajur, jenis data object ialah pilihan umum untuk rentetan dan jenis bercampur, manakala df.info() memberikan gambaran keseluruhan yang lengkap tentang jenis dan kebolehbatalan. Gunakan select_dtypes() untuk menapis lajur mengikut keluarga jenis dan tambahkan pengesahan jenis data bagi mengesan perubahan skema dalam pengeluaran. Seterusnya, kita akan menukar lajur kepada jenis data yang betul menggunakan astype().
Pelajari Python dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 30
- Pelajaran
- 120
Soalan Lazim
Adakah pelajaran “Memeriksa Jenis Data Lajur” percuma?
Ya — teks penuh “Memeriksa Jenis Data Lajur” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Pandas & NumPy Academy, tingkat taraf kepada CoddyKit PRO. Kursus Pandas & NumPy Academy merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Memeriksa Jenis Data Lajur”?
Baca atribut dtypes, bezakan int64 daripada float64 dan object, serta kenal pasti lajur yang memerlukan penukaran. Anda berlatih Pandas & NumPy Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Pandas & NumPy Academy?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Pandas & NumPy Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.
Berapa lamakah pelajaran “Memeriksa Jenis Data Lajur” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Pandas & NumPy Academy ini?
Ya. Setiap pelajaran Pandas & NumPy Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Memeriksa Jenis Data Lajur
- Penukaran Jenis dengan astype()
- Jenis Data Kategori
- Menghurai Tarikh dengan Betul