Perbedaan antara data yang ditemukan di banyak tutorial dan data di dunia nyata adalah bahwa data dunia nyata jarang bersih dan homogen. Secara khusus, banyak kumpulan data yang menarik akan kehilangan sejumlah data. Lebih rumit lagi, sumber data yang berbeda mungkin menunjukkan data yang hilang dengan cara yang berbeda
Pada bagian ini, kita akan membahas beberapa pertimbangan umum untuk data yang hilang, mendiskusikan bagaimana Panda memilih untuk merepresentasikannya, dan mendemonstrasikan beberapa alat Pandas bawaan untuk menangani data yang hilang di Python. Di sini dan di sepanjang buku ini, kami akan mengacu pada data yang hilang secara umum sebagai nilai null, NaN, atau NA
Trade-Off dalam Konvensi Data yang Hilang
Ada sejumlah skema yang telah dikembangkan untuk menunjukkan adanya data yang hilang dalam sebuah tabel atau DataFrame. Umumnya, mereka berputar di sekitar salah satu dari dua strategi. menggunakan topeng yang secara global menunjukkan nilai yang hilang, atau memilih nilai sentinel yang menunjukkan entri yang hilang
Dalam pendekatan masking, mask mungkin merupakan array Boolean yang sepenuhnya terpisah, atau mungkin melibatkan apropriasi satu bit dalam representasi data untuk secara lokal menunjukkan status null dari suatu nilai.
Dalam pendekatan sentinel, nilai sentinel dapat berupa konvensi khusus data, seperti menunjukkan nilai bilangan bulat yang hilang dengan -9999 atau beberapa pola bit langka, atau dapat berupa konvensi yang lebih global, seperti menunjukkan nilai floating-point yang hilang
Tak satu pun dari pendekatan ini tanpa kompromi. penggunaan larik topeng terpisah memerlukan alokasi larik Boolean tambahan, yang menambahkan overhead dalam penyimpanan dan perhitungan. Nilai sentinel mengurangi rentang nilai valid yang dapat direpresentasikan, dan mungkin memerlukan logika ekstra (seringkali tidak dioptimalkan) dalam aritmatika CPU dan GPU. Nilai khusus umum seperti NaN tidak tersedia untuk semua tipe data
Seperti dalam kebanyakan kasus di mana tidak ada pilihan optimal universal, bahasa dan sistem yang berbeda menggunakan konvensi yang berbeda. Misalnya, bahasa R menggunakan pola bit yang dicadangkan dalam setiap tipe data sebagai nilai sentinel yang menunjukkan data yang hilang, sedangkan sistem SciDB menggunakan byte tambahan yang dilampirkan ke setiap sel yang menunjukkan status NA.
Data Hilang di Pandas
Cara Panda menangani nilai yang hilang dibatasi oleh ketergantungannya pada paket NumPy, yang tidak memiliki gagasan bawaan tentang nilai NA untuk tipe data non-floating-point
Panda bisa mengikuti jejak R dalam menentukan pola bit untuk setiap tipe data individual untuk menunjukkan nullness, tetapi pendekatan ini ternyata agak berat. Sementara R berisi empat tipe data dasar, NumPy mendukung lebih dari ini. misalnya, sementara R memiliki tipe bilangan bulat tunggal, NumPy mendukung empat belas tipe bilangan bulat dasar setelah Anda memperhitungkan ketepatan, keabsahan, dan ketetapan pengkodean yang tersedia. Mencadangkan pola bit tertentu di semua jenis NumPy yang tersedia akan menyebabkan jumlah overhead yang berat dalam berbagai operasi casing khusus untuk berbagai jenis, bahkan kemungkinan membutuhkan fork baru dari paket NumPy. Selanjutnya, untuk tipe data yang lebih kecil (seperti bilangan bulat 8-bit), mengorbankan sedikit untuk digunakan sebagai topeng akan secara signifikan mengurangi rentang nilai yang dapat diwakilinya.
NumPy memiliki dukungan untuk array bertopeng – yaitu, array yang memiliki array topeng Boolean terpisah yang dilampirkan untuk menandai data sebagai "baik" atau "buruk. " Panda bisa jadi berasal dari ini, tetapi overhead dalam penyimpanan, komputasi, dan pemeliharaan kode menjadikannya pilihan yang tidak menarik
Dengan mempertimbangkan batasan ini, Panda memilih untuk menggunakan sentinel untuk data yang hilang, dan selanjutnya memilih untuk menggunakan dua nilai nol Python yang sudah ada. nilai titik-mengambang khusus dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop _6, dan objek Python dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop 7. Pilihan ini memiliki beberapa efek samping, seperti yang akan kita lihat, tetapi dalam praktiknya akhirnya menjadi kompromi yang baik dalam banyak kasus yang menarik
dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop _7. Data Pythonic hilang
Nilai sentinel pertama yang digunakan oleh Panda adalah dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop 7, objek tunggal Python yang sering digunakan untuk data yang hilang dalam kode Python. Karena ini adalah objek Python, dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop _7 tidak dapat digunakan dalam sembarang array NumPy/Pandas, tetapi hanya dalam array dengan tipe data vals1.sum() 1 (i. e. , array objek Python)
Dalam [1]
import numpy as np import pandas as pd _
Di [2]
vals1 = np.array([1, None, 3, 4]) vals1
Keluar[2]
array([1, None, 3, 4], dtype=object)_
vals1.sum() _2 ini berarti bahwa representasi tipe umum terbaik yang dapat disimpulkan oleh NumPy untuk konten array adalah bahwa mereka adalah objek Python. Meskipun array objek semacam ini berguna untuk beberapa tujuan, setiap operasi pada data akan dilakukan pada tingkat Python, dengan lebih banyak overhead daripada operasi cepat yang biasanya terlihat untuk array dengan tipe asli
Dalam [3]
for dtype in ['object', 'int']: print("dtype =", dtype) %timeit np.arange(1E6, dtype=dtype).sum() print()
dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop
Penggunaan objek Python dalam array juga berarti bahwa jika Anda melakukan agregasi seperti vals1.sum() 3 atau vals1.sum() 4 melintasi array dengan nilai dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop 7, Anda biasanya akan mendapatkan kesalahan
Di [4]
vals1.sum()
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-4-749fd8ae6030> in <module>() ----> 1 vals1.sum() /Users/jakevdp/anaconda/lib/python3.5/site-packages/numpy/core/_methods.py in _sum(a, axis, dtype, out, keepdims) 30 31 def _sum(a, axis=None, dtype=None, out=None, keepdims=False): ---> 32 return umr_sum(a, axis, dtype, out, keepdims) 33 34 def _prod(a, axis=None, dtype=None, out=None, keepdims=False): TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'
Ini mencerminkan fakta bahwa penambahan antara bilangan bulat dan dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop 7 tidak terdefinisi
dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop _6. Data numerik tidak ada
Representasi data lain yang hilang, dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop _6 (singkatan dari Not a Number), berbeda;
Dalam [5]
vals2 = np.array([1, np.nan, 3, 4]) vals2.dtype
Keluar[5]
dtype('float64')
Perhatikan bahwa NumPy memilih tipe floating-point asli untuk array ini. ini berarti bahwa tidak seperti larik objek sebelumnya, larik ini mendukung operasi cepat yang dimasukkan ke dalam kode yang dikompilasi. Anda harus menyadari bahwa dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop 6 sedikit mirip dengan virus data–ia menginfeksi objek lain yang disentuhnya. Terlepas dari operasinya, hasil aritmatika dengan dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop 6 akan menjadi dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop 6 lainnya
Di [6]
1 + np.nan
Keluar[6]
vals1 = np.array([1, None, 3, 4]) vals1 0
Di [7]
vals1 = np.array([1, None, 3, 4]) vals1 1
Keluar[7]
vals1 = np.array([1, None, 3, 4]) vals1 0
Perhatikan bahwa ini berarti bahwa agregat atas nilai didefinisikan dengan baik (mis. e. , mereka tidak menghasilkan kesalahan) tetapi tidak selalu berguna
Di [8]
vals1 = np.array([1, None, 3, 4]) vals1 3
Keluar[8]
vals1 = np.array([1, None, 3, 4]) vals1 4
NumPy memang menyediakan beberapa agregasi khusus yang akan mengabaikan nilai yang hilang ini
Dalam [9]
vals1 = np.array([1, None, 3, 4]) vals1 5
Keluar[9]
vals1 = np.array([1, None, 3, 4]) vals1 6
Perlu diingat bahwa dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop _6 secara khusus merupakan nilai floating-point;
NaN dan Tidak Ada di Panda
dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop 6 dan dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop 7 keduanya memiliki tempatnya masing-masing, dan Panda dibangun untuk menangani keduanya hampir secara bergantian, mengubah di antara keduanya jika perlu
Di [10]
vals1 = np.array([1, None, 3, 4]) vals1 7
Keluar[10]
vals1 = np.array([1, None, 3, 4]) vals1 _8
Untuk tipe yang tidak memiliki nilai sentinel yang tersedia, Pandas secara otomatis mengetik ketika nilai NA ada. Misalnya, jika kita menetapkan nilai dalam larik bilangan bulat ke --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-4-749fd8ae6030> in <module>() ----> 1 vals1.sum() /Users/jakevdp/anaconda/lib/python3.5/site-packages/numpy/core/_methods.py in _sum(a, axis, dtype, out, keepdims) 30 31 def _sum(a, axis=None, dtype=None, out=None, keepdims=False): ---> 32 return umr_sum(a, axis, dtype, out, keepdims) 33 34 def _prod(a, axis=None, dtype=None, out=None, keepdims=False): TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'5, maka secara otomatis akan dialihkan ke tipe floating-point untuk mengakomodasi NA
Di [11]
vals1 = np.array([1, None, 3, 4]) vals1 _9
Keluar[11]
array([1, None, 3, 4], dtype=object)_0
Dalam [12]
array([1, None, 3, 4], dtype=object)_1
Keluar[12]
array([1, None, 3, 4], dtype=object)_2
Perhatikan bahwa selain mentransmisi array bilangan bulat ke floating point, Panda secara otomatis mengonversi nilai dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop 7 menjadi nilai dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop 6. (Ketahuilah bahwa ada proposal untuk menambahkan bilangan bulat asli NA ke Pandas di masa mendatang; hingga tulisan ini dibuat, itu belum disertakan)
Sementara jenis sihir ini mungkin terasa sedikit meretas dibandingkan dengan pendekatan yang lebih terpadu untuk nilai NA dalam bahasa khusus domain seperti R, pendekatan sentinel/casting Panda bekerja cukup baik dalam praktiknya dan menurut pengalaman saya jarang menyebabkan masalah
Tabel berikut mencantumkan konvensi upcasting di Pandas saat nilai NA diperkenalkan
TypeclassConversion Saat menyimpan nilai sentinel nasna--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-4-749fd8ae6030> in <module>() ----> 1 vals1.sum() /Users/jakevdp/anaconda/lib/python3.5/site-packages/numpy/core/_methods.py in _sum(a, axis, dtype, out, keepdims) 30 31 def _sum(a, axis=None, dtype=None, out=None, keepdims=False): ---> 32 return umr_sum(a, axis, dtype, out, keepdims) 33 34 def _prod(a, axis=None, dtype=None, out=None, keepdims=False): TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'8no perubahan--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-4-749fd8ae6030> in <module>() ----> 1 vals1.sum() /Users/jakevdp/anaconda/lib/python3.5/site-packages/numpy/core/_methods.py in _sum(a, axis, dtype, out, keepdims) 30 31 def _sum(a, axis=None, dtype=None, out=None, keepdims=False): ---> 32 return umr_sum(a, axis, dtype, out, keepdims) 33 34 def _prod(a, axis=None, dtype=None, out=None, keepdims=False): TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'5vals2 = np.array([1, np.nan, 3, 4]) vals2.dtype 0 tidak berubah____0___________7 atau --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-4-749fd8ae6030> in <module>() ----> 1 vals1.sum() /Users/jakevdp/anaconda/lib/python3.5/site-packages/numpy/core/_methods.py in _sum(a, axis, dtype, out, keepdims) 30 31 def _sum(a, axis=None, dtype=None, out=None, keepdims=False): ---> 32 return umr_sum(a, axis, dtype, out, keepdims) 33 34 def _prod(a, axis=None, dtype=None, out=None, keepdims=False): TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'5___________________________________________________________________________________________.Perlu diingat bahwa di Pandas, data string selalu disimpan dengan tipe vals2 = np.array([1, np.nan, 3, 4]) vals2.dtype 0
Beroperasi pada Nilai Null
Seperti yang telah kita lihat, Panda memperlakukan dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop 7 dan dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop 6 pada dasarnya dapat dipertukarkan untuk menunjukkan nilai yang hilang atau nol. Untuk memfasilitasi konvensi ini, ada beberapa metode berguna untuk mendeteksi, menghapus, dan mengganti nilai nol dalam struktur data Pandas. Mereka
- dtype('float64')3. Hasilkan topeng boolean yang menunjukkan nilai yang hilang
- dtype('float64')4. Kebalikan dari dtype('float64')3
- dtype('float64')6. Kembalikan versi data yang difilter
- dtype('float64')7. Kembalikan salinan data dengan nilai yang hilang diisi atau diperhitungkan
Kami akan mengakhiri bagian ini dengan eksplorasi singkat dan demonstrasi rutinitas ini
Mendeteksi nilai null
Struktur data panda memiliki dua metode yang berguna untuk mendeteksi data null. dtype('float64')3 dan dtype('float64')4. Salah satunya akan mengembalikan topeng Boolean di atas data. Sebagai contoh
Di [13]
array([1, None, 3, 4], dtype=object)_3
Dalam [14]
array([1, None, 3, 4], dtype=object)_4
Keluar[14]
array([1, None, 3, 4], dtype=object)_5
Seperti disebutkan dalam Pengindeksan dan Pemilihan Data, topeng Boolean dapat digunakan secara langsung sebagai indeks 1 + np.nan 0 atau 1 + np.nan 1
Di [15]
array([1, None, 3, 4], dtype=object)_6
Keluar[15]
array([1, None, 3, 4], dtype=object)_7
Metode dtype('float64')_3 dan dtype('float64')4 menghasilkan hasil Boolean yang serupa untuk 1 + np.nan 1s
Menjatuhkan nilai nol
Selain masking yang digunakan sebelumnya, ada metode praktis, dtype('float64')6 (yang menghilangkan nilai NA) dan dtype('float64')7 (yang mengisi nilai NA). Untuk 1 + np.nan _0, hasilnya langsung
Dalam [16]
array([1, None, 3, 4], dtype=object)_8
Keluar[16]
array([1, None, 3, 4], dtype=object)_7
Untuk 1 + np.nan _1, ada lebih banyak opsi. Pertimbangkan hal berikut 1 + np.nan _1
Dalam [17]
for dtype in ['object', 'int']: print("dtype =", dtype) %timeit np.arange(1E6, dtype=dtype).sum() print() _0
Keluar[17]
01201. 0NaN212. 03. 052NaN4. 06
Kami tidak dapat menghapus nilai tunggal dari 1 + np.nan 1; . Bergantung pada aplikasinya, Anda mungkin menginginkan satu atau yang lain, jadi dtype('float64')6 memberikan sejumlah opsi untuk 1 + np.nan 1
Secara default, dtype('float64')_6 akan menghapus semua baris yang berisi nilai null
Dalam [18]
for dtype in ['object', 'int']: print("dtype =", dtype) %timeit np.arange(1E6, dtype=dtype).sum() print() _1
Keluar[18]
01212. 03. 05
Alternatifnya, Anda dapat membuang nilai NA di sepanjang sumbu yang berbeda;
Dalam [19]
for dtype in ['object', 'int']: print("dtype =", dtype) %timeit np.arange(1E6, dtype=dtype).sum() print() _2
Keluar[19]
2021526
Tapi ini juga memberikan beberapa data bagus; . Ini dapat ditentukan melalui parameter vals1 = np.array([1, None, 3, 4]) vals1 _05 atau vals1 = np.array([1, None, 3, 4]) vals1 06, yang memungkinkan kontrol yang baik atas jumlah nol yang diizinkan
Standarnya adalah vals1 = np.array([1, None, 3, 4]) vals1 _07, sehingga setiap baris atau kolom (bergantung pada kata kunci vals1 = np.array([1, None, 3, 4]) vals1 08) yang berisi nilai nol akan dibuang. Anda juga dapat menentukan vals1 = np.array([1, None, 3, 4]) vals1 09, yang hanya akan menghapus baris/kolom yang semuanya bernilai nol
Dalam [20]
for dtype in ['object', 'int']: print("dtype =", dtype) %timeit np.arange(1E6, dtype=dtype).sum() print() _3
Keluar[20]
012301. 0NaN2NaN12. 03. 05NaN2NaN4. 06NaN
Dalam [21]
for dtype in ['object', 'int']: print("dtype =", dtype) %timeit np.arange(1E6, dtype=dtype).sum() print() _4
Keluar[21]
01201. 0NaN212. 03. 052NaN4. 06
Untuk kontrol yang lebih halus, parameter vals1 = np.array([1, None, 3, 4]) vals1 _06 memungkinkan Anda menentukan jumlah minimum nilai non-null untuk baris/kolom yang akan dipertahankan
Di [22]
for dtype in ['object', 'int']: print("dtype =", dtype) %timeit np.arange(1E6, dtype=dtype).sum() print() _5
Keluar[22]
012312. 03. 05NaN
Di sini baris pertama dan terakhir telah dihapus, karena hanya berisi dua nilai bukan nol
Mengisi nilai null
Terkadang daripada menghilangkan nilai NA, Anda lebih suka menggantinya dengan nilai yang valid. Nilai ini mungkin berupa angka tunggal seperti nol, atau mungkin semacam imputasi atau interpolasi dari nilai yang baik. Anda bisa melakukan ini di tempat menggunakan metode dtype('float64')_3 sebagai topeng, tetapi karena ini adalah operasi yang umum, Pandas menyediakan metode dtype('float64')7, yang mengembalikan salinan array dengan nilai null diganti
Perhatikan 1 + np.nan 0 berikut ini
Dalam [23]
for dtype in ['object', 'int']: print("dtype =", dtype) %timeit np.arange(1E6, dtype=dtype).sum() print() _6
Keluar[23]
for dtype in ['object', 'int']: print("dtype =", dtype) %timeit np.arange(1E6, dtype=dtype).sum() print() _7
Kita dapat mengisi entri NA dengan satu nilai, seperti nol
Di [24]
for dtype in ['object', 'int']: print("dtype =", dtype) %timeit np.arange(1E6, dtype=dtype).sum() print() _8
Keluar[24]
for dtype in ['object', 'int']: print("dtype =", dtype) %timeit np.arange(1E6, dtype=dtype).sum() print() _9
Kita dapat menentukan forward-fill untuk menyebarkan nilai sebelumnya ke depan
Dalam [25]
dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop 0
Keluar[25]
dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop _1
Atau kita dapat menentukan back-fill untuk menyebarkan nilai berikutnya ke belakang
Dalam [26]
dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop _2
Keluar[26]
dtype = object 10 loops, best of 3: 78.2 ms per loop dtype = int 100 loops, best of 3: 3.06 ms per loop _3
Untuk 1 + np.nan _1s, opsinya serupa, tetapi kami juga dapat menentukan vals1 = np.array([1, None, 3, 4]) vals1 08 di mana pengisian berlangsung