Hướng dẫn how do you skip nan in python? - làm thế nào để bạn bỏ qua nan trong python?

Mặc định là

df.dropna()

df.dropna()

df.dropna()

Đối với điều khiển chi tiết hơn, tham số

df.dropna()

Ở đây hàng đầu tiên và hàng cuối cùng đã bị loại bỏ, vì chúng chỉ chứa hai giá trị không null.

Lấp đầy các giá trị null

Đôi khi thay vì bỏ các giá trị NA, bạn muốn thay thế chúng bằng một giá trị hợp lệ. Giá trị này có thể là một số duy nhất như số không, hoặc nó có thể là một loại cắt hoặc nội suy từ các giá trị tốt. Bạn có thể thực hiện tại chỗ bằng cách sử dụng phương thức

   values_1   values_2
2     500.0      350.0
4    1200.0     5000.0

df.reset_index(drop=True)

Hãy xem xét các

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()
df = df.reset_index(drop=True)

print (df)

Không có cách tiếp cận nào trong số này là không có sự đánh đổi: Sử dụng một mảng mặt nạ riêng biệt yêu cầu phân bổ một mảng boolean bổ sung, điều này bổ sung chi phí trong cả lưu trữ và tính toán. Một giá trị sentinel làm giảm phạm vi của các giá trị hợp lệ có thể được biểu diễn và có thể yêu cầu logic thêm (thường không được tối ưu hóa) trong số học CPU và GPU. Các giá trị đặc biệt phổ biến như NAN không có sẵn cho tất cả các loại dữ liệu.

Như trong hầu hết các trường hợp không có lựa chọn tối ưu phổ biến tồn tại, các ngôn ngữ và hệ thống khác nhau sử dụng các quy ước khác nhau. Ví dụ: ngôn ngữ R sử dụng các mẫu bit dành riêng trong mỗi loại dữ liệu làm giá trị sentinel cho biết dữ liệu bị thiếu, trong khi hệ thống SCIDB sử dụng một byte phụ được gắn vào mọi ô cho biết trạng thái NA.

Thiếu dữ liệu trong Pandas¶

Cách mà gấu trúc xử lý các giá trị bị thiếu bị hạn chế bởi sự phụ thuộc của nó vào gói Numpy, không có khái niệm tích hợp về các giá trị NA cho các loại dữ liệu không nổi.

Pandas có thể đã theo hướng dẫn của R trong việc chỉ định các mẫu bit cho từng loại dữ liệu riêng lẻ để chỉ ra sự vô hiệu, nhưng phương pháp này hóa ra là khá khó sử dụng. Mặc dù R chứa bốn loại dữ liệu cơ bản, Numpy hỗ trợ nhiều hơn thế này: ví dụ: trong khi R có một loại số nguyên duy nhất, Numpy hỗ trợ mười bốn loại số nguyên cơ bản khi bạn tính đến các độ trước, độ ký hợp đồng và tính của mã hóa. Đặt một mẫu bit cụ thể trong tất cả các loại numpy có sẵn sẽ dẫn đến một lượng chi phí khó sử dụng trong các hoạt động đặc biệt cho các loại khác nhau, thậm chí có thể yêu cầu một ngã ba mới của gói Numpy. Hơn nữa, đối với các loại dữ liệu nhỏ hơn (chẳng hạn như số nguyên 8 bit), việc hy sinh một chút để sử dụng làm mặt nạ sẽ làm giảm đáng kể phạm vi các giá trị mà nó có thể biểu thị.

Numpy có hỗ trợ cho các mảng đeo mặt nạ - nghĩa là các mảng có mảng mặt nạ boolean riêng được gắn để đánh dấu dữ liệu là "tốt" hoặc "xấu". Pandas có thể bắt nguồn từ điều này, nhưng chi phí trong cả lưu trữ, tính toán và bảo trì mã làm cho nó trở thành một lựa chọn không hấp dẫn.

Với những ràng buộc này, Pandas đã chọn sử dụng Sentinels để thiếu dữ liệu và chọn thêm để sử dụng hai giá trị Python Null đã tồn tại: giá trị

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

import pandas as pd df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'], 'values_2': ['DDD','150','350','400','5000'] }) df = df.apply (pd.to_numeric, errors='coerce') print (df) 3: Dữ liệu thiếu Pythonic

Giá trị Sentinel đầu tiên được sử dụng bởi Pandas là

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

In [1]:

df.dropna()

In [2]:

df.dropna()

Out[2]:

df.dropna()

Điều này

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

In [3]:

df.dropna()

df.dropna()

Việc sử dụng các đối tượng Python trong một mảng cũng có nghĩa là nếu bạn thực hiện các tập hợp như

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

   values_1   values_2
0     700.0        NaN
1       NaN      150.0
2     500.0      350.0
3       NaN      400.0
4    1200.0     5000.0

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

df.dropna()

Điều này phản ánh thực tế rằng sự bổ sung giữa số nguyên và

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

import pandas as pd df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'], 'values_2': ['DDD','150','350','400','5000'] }) df = df.apply (pd.to_numeric, errors='coerce') print (df) 2: Thiếu dữ liệu số

Biểu diễn dữ liệu bị thiếu khác,

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

In [5]:

df.dropna()

Lưu ý rằng Numpy đã chọn một loại dấu phẩy động gốc cho mảng này: điều này có nghĩa là không giống như mảng đối tượng từ trước, mảng này hỗ trợ các hoạt động nhanh được đẩy vào mã được biên dịch. Bạn nên lưu ý rằng

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

Lưu ý rằng điều này có nghĩa là tổng hợp các giá trị được xác định rõ (nghĩa là, chúng không dẫn đến lỗi) nhưng không phải lúc nào cũng hữu ích:

In [8]:

df.dropna()

Numpy không cung cấp một số tập hợp đặc biệt sẽ bỏ qua các giá trị bị thiếu này:

In [9]:

df.dropna()

Hãy nhớ rằng

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

Nan và không có ở Pandas¶

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

In [10]:

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

print (df)

Out[10]:

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

print (df)

Đối với các loại không có giá trị sentinel có sẵn, gấu trúc tự động loại đúc khi có giá trị Na. Ví dụ: nếu chúng ta đặt giá trị trong một mảng số nguyên thành

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()

print (df)

In [11]:

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

print (df)

Out[12]:

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

print (df)

Lưu ý rằng ngoài việc đúc mảng số nguyên thành điểm nổi, gấu trúc tự động chuyển đổi

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

Mặc dù loại ma thuật này có thể cảm thấy hơi hack so với cách tiếp cận thống nhất hơn đối với các giá trị NA trong các ngôn ngữ cụ thể về miền như R, phương pháp tiếp cận Sentinel/Casting của Pandas hoạt động khá tốt trong thực tế và theo kinh nghiệm của tôi chỉ hiếm khi gây ra vấn đề.

Bảng sau đây liệt kê các quy ước upcasting trong gấu trúc khi các giá trị NA được giới thiệu:

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()

print (df)

import pandas as pd df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'], 'values_2': ['DDD','150','350','400','5000'] }) df = df.apply (pd.to_numeric, errors='coerce') print (df) 3 hoặc import pandas as pd df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'], 'values_2': ['DDD','150','350','400','5000'] }) df = df.apply (pd.to_numeric, errors='coerce') df = df.dropna() print (df) 1

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()

print (df)

• Đúc đến

     values_1   values_2
  2     500.0      350.0
  4    1200.0     5000.0
  

  0

•    values_1   values_2
  2     500.0      350.0
  4    1200.0     5000.0
  

  2
• Đúc đến

  import pandas as pd
  
  df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                     'values_2': ['DDD','150','350','400','5000'] 
                     })
  
  df = df.apply (pd.to_numeric, errors='coerce')
  df = df.dropna()
  
  print (df)
  

  6
• Hãy nhớ rằng trong gấu trúc, dữ liệu chuỗi luôn được lưu trữ với

  import pandas as pd
  
  df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                     'values_2': ['DDD','150','350','400','5000'] 
                     })
  
  df = df.apply (pd.to_numeric, errors='coerce')
  df = df.dropna()
  
  print (df)
  

  6 DTYPE.

Hoạt động trên Null Value¶

Như chúng ta đã thấy, Pandas xử lý import pandas as pd df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'], 'values_2': ['DDD','150','350','400','5000'] }) df = df.apply (pd.to_numeric, errors='coerce') print (df) 3 và import pandas as pd df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'], 'values_2': ['DDD','150','350','400','5000'] }) df = df.apply (pd.to_numeric, errors='coerce') print (df) 2 về cơ bản có thể hoán đổi cho nhau để chỉ ra các giá trị thiếu hoặc null. Để tạo điều kiện cho quy ước này, có một số phương pháp hữu ích để phát hiện, loại bỏ và thay thế các giá trị null trong các cấu trúc dữ liệu gấu trúc. Họ đang:

   values_1   values_2
2     500.0      350.0
4    1200.0     5000.0

In [13]:

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

print (df)

Out[14]:

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

print (df)

Out[15]:

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

print (df)

df.reset_index(drop=True)

   values_1   values_2
2     500.0      350.0
4    1200.0     5000.0

df.reset_index(drop=True) 2: Trả về phiên bản lọc dữ liệu

df.reset_index(drop=True)

Out[16]:

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

print (df)

Chúng tôi sẽ kết thúc phần này với một cuộc thăm dò ngắn gọn và trình diễn các thói quen này.

In [17]:

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

print (df)

Out[17]:

Cấu trúc dữ liệu PANDAS có hai phương pháp hữu ích để phát hiện dữ liệu null:

   values_1   values_2
2     500.0      350.0
4    1200.0     5000.0

df.reset_index(drop=True)

Các phương pháp

   values_1   values_2
2     500.0      350.0
4    1200.0     5000.0

df.reset_index(drop=True)

df.reset_index(drop=True)

Bỏ giá trị null

Ngoài mặt nạ được sử dụng trước đó, còn có các phương thức tiện lợi,

df.reset_index(drop=True)

df.reset_index(drop=True)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()
df = df.reset_index(drop=True)

print (df)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

print (df)

Đối với một

df.reset_index(drop=True)

df.reset_index(drop=True)

Nan

Out[20]:

In [21]:

  values_1   values_2
0      700        DDD
1      ABC        150
2      500        350
3      XYZ        400
4     1200       5000

Out[21]:

Cấu trúc dữ liệu PANDAS có hai phương pháp hữu ích để phát hiện dữ liệu null:

   values_1   values_2
2     500.0      350.0
4    1200.0     5000.0

df.reset_index(drop=True)

In [22]:

  values_1   values_2
0      700        DDD
1      ABC        150
2      500        350
3      XYZ        400
4     1200       5000

Các phương pháp

   values_1   values_2
2     500.0      350.0
4    1200.0     5000.0

df.reset_index(drop=True)

df.reset_index(drop=True)

Bỏ giá trị null

Ngoài mặt nạ được sử dụng trước đó, còn có các phương thức tiện lợi,

df.reset_index(drop=True)

df.reset_index(drop=True)

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()
df = df.reset_index(drop=True)

print (df)

Hãy xem xét các

import pandas as pd

df = pd.DataFrame({'values_1': ['700','ABC','500','XYZ','1200'],
                   'values_2': ['DDD','150','350','400','5000'] 
                   })

df = df.apply (pd.to_numeric, errors='coerce')
df = df.dropna()
df = df.reset_index(drop=True)

print (df)

In [23]:

  values_1   values_2
0      700        DDD
1      ABC        150
2      500        350
3      XYZ        400
4     1200       5000

Out[23]:

  values_1   values_2
0      700        DDD
1      ABC        150
2      500        350
3      XYZ        400
4     1200       5000

Chúng ta có thể điền vào các mục NA với một giá trị duy nhất, chẳng hạn như Zero:

Out[24]:

  values_1   values_2
0      700        DDD
1      ABC        150
2      500        350
3      XYZ        400
4     1200       5000

Chúng tôi có thể chỉ định một forward filling để truyền giá trị trước đó:

In [25]:

  values_1   values_2
0      700        DDD
1      ABC        150
2      500        350
3      XYZ        400
4     1200       5000

Out[25]:

  values_1   values_2
0      700        DDD
1      ABC        150
2      500        350
3      XYZ        400
4     1200       5000

Hoặc chúng ta có thể chỉ định một phần quay ngược để truyền các giá trị tiếp theo ngược:

In [26]:

  values_1   values_2
0      700        DDD
1      ABC        150
2      500        350
3      XYZ        400
4     1200       5000

Out[26]:

  values_1   values_2
0      700        DDD
1      ABC        150
2      500        350
3      XYZ        400
4     1200       5000

Đối với

df.reset_index(drop=True)

df.dropna()

Out[27]:

In [28]:

  values_1   values_2
0      700        DDD
1      ABC        150
2      500        350
3      XYZ        400
4     1200       5000

Out[28]:

Lưu ý rằng nếu một giá trị trước đó không có sẵn trong quá trình điền chuyển tiếp, giá trị NA vẫn còn.