programming python

Binning Python

Trong 

print[pd.cut[s, [0, 10, 50, 100]]]
# a          NaN
# b      [0, 10]
# c      [0, 10]
# d      [0, 10]
# e     [10, 50]
# f     [10, 50]
# g     [10, 50]
# h     [10, 50]
# i    [50, 100]
# j    [50, 100]
# k    [50, 100]
# dtype: category
# Categories [3, interval[int64]]: [[0, 10] < [10, 50] < [50, 100]]
1, tham số đầu tiên 
s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
5 là mảng một chiều [danh sách Python hoặc 
s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
6, 
s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
2] làm dữ liệu nguồn và tham số thứ hai 
s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
8 là cài đặt phân chia bin

Chỉ định số lượng thùng có chiều rộng bằng nhau

Bạn có thể chỉ định số ngăn có chiều rộng bằng nhau bằng cách chỉ định giá trị số nguyên cho 

s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
8

s_cut = pd.cut[s, 4]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[type[s_cut]]
#

nguồn. 

print[pd.cut[s, 4, right=False]]
# a      [0.0, 25.0]
# b      [0.0, 25.0]
# c      [0.0, 25.0]
# d      [0.0, 25.0]
# e      [0.0, 25.0]
# f     [25.0, 50.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.1]
# k    [75.0, 100.1]
# dtype: category
# Categories [4, interval[float64]]: [[0.0, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.1]]
0 có nghĩa là 
print[pd.cut[s, 4, right=False]]
# a      [0.0, 25.0]
# b      [0.0, 25.0]
# c      [0.0, 25.0]
# d      [0.0, 25.0]
# e      [0.0, 25.0]
# f     [25.0, 50.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.1]
# k    [75.0, 100.1]
# dtype: category
# Categories [4, interval[float64]]: [[0.0, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.1]]
1

Chỉ định các cạnh thùng [giá trị biên]

Bạn có thể chỉ định các cạnh của thùng, các giá trị biên, bằng cách chỉ định một danh sách cho 

s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
8. Các yếu tố bên ngoài phạm vi được coi là 
print[pd.cut[s, 4, right=False]]
# a      [0.0, 25.0]
# b      [0.0, 25.0]
# c      [0.0, 25.0]
# d      [0.0, 25.0]
# e      [0.0, 25.0]
# f     [25.0, 50.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.1]
# k    [75.0, 100.1]
# dtype: category
# Categories [4, interval[float64]]: [[0.0, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.1]]
3

print[pd.cut[s, [0, 10, 50, 100]]]
# a          NaN
# b      [0, 10]
# c      [0, 10]
# d      [0, 10]
# e     [10, 50]
# f     [10, 50]
# g     [10, 50]
# h     [10, 50]
# i    [50, 100]
# j    [50, 100]
# k    [50, 100]
# dtype: category
# Categories [3, interval[int64]]: [[0, 10] < [10, 50] < [50, 100]]

nguồn.

Nhận các thùng được tính toán hoặc được chỉ định. 
print[pd.cut[s, [0, 10, 50, 100]]]
# a          NaN
# b      [0, 10]
# c      [0, 10]
# d      [0, 10]
# e     [10, 50]
# f     [10, 50]
# g     [10, 50]
# h     [10, 50]
# i    [50, 100]
# j    [50, 100]
# k    [50, 100]
# dtype: category
# Categories [3, interval[int64]]: [[0, 10] < [10, 50] < [50, 100]]
6

Với 

print[pd.cut[s, 4, right=False]]
# a      [0.0, 25.0]
# b      [0.0, 25.0]
# c      [0.0, 25.0]
# d      [0.0, 25.0]
# e      [0.0, 25.0]
# f     [25.0, 50.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.1]
# k    [75.0, 100.1]
# dtype: category
# Categories [4, interval[float64]]: [[0.0, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.1]]
5, bạn có thể nhận được thùng, tôi. e. , một danh sách các giá trị biên ngoài dữ liệu được đánh dấu

s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#

nguồn.

Chỉ định có bao gồm cạnh ngoài cùng bên phải hay không. 
print[pd.cut[s, [0, 10, 50, 100]]]
# a          NaN
# b      [0, 10]
# c      [0, 10]
# d      [0, 10]
# e     [10, 50]
# f     [10, 50]
# g     [10, 50]
# h     [10, 50]
# i    [50, 100]
# j    [50, 100]
# k    [50, 100]
# dtype: category
# Categories [3, interval[int64]]: [[0, 10] < [10, 50] < [50, 100]]
7

Theo mặc định, cạnh ngoài cùng bên phải được bao gồm và cạnh ngoài cùng bên trái không. Ngược lại, nếu 

print[pd.cut[s, 4, right=False]]
# a      [0.0, 25.0]
# b      [0.0, 25.0]
# c      [0.0, 25.0]
# d      [0.0, 25.0]
# e      [0.0, 25.0]
# f     [25.0, 50.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.1]
# k    [75.0, 100.1]
# dtype: category
# Categories [4, interval[float64]]: [[0.0, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.1]]
7, cạnh ngoài cùng bên phải không được bao gồm

print[pd.cut[s, 4, right=False]]
# a      [0.0, 25.0]
# b      [0.0, 25.0]
# c      [0.0, 25.0]
# d      [0.0, 25.0]
# e      [0.0, 25.0]
# f     [25.0, 50.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.1]
# k    [75.0, 100.1]
# dtype: category
# Categories [4, interval[float64]]: [[0.0, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.1]]

nguồn.

Chỉ định nhãn. 
print[pd.cut[s, [0, 10, 50, 100]]]
# a          NaN
# b      [0, 10]
# c      [0, 10]
# d      [0, 10]
# e     [10, 50]
# f     [10, 50]
# g     [10, 50]
# h     [10, 50]
# i    [50, 100]
# j    [50, 100]
# k    [50, 100]
# dtype: category
# Categories [3, interval[int64]]: [[0, 10] < [10, 50] < [50, 100]]
8

Bạn có thể chỉ định nhãn với tham số 

print[pd.cut[s, [0, 10, 50, 100]]]
# a          NaN
# b      [0, 10]
# c      [0, 10]
# d      [0, 10]
# e     [10, 50]
# f     [10, 50]
# g     [10, 50]
# h     [10, 50]
# i    [50, 100]
# j    [50, 100]
# k    [50, 100]
# dtype: category
# Categories [3, interval[int64]]: [[0, 10] < [10, 50] < [50, 100]]
8. Các nhãn mặc định giống như 
print[pd.cut[s, 4, right=False]]
# a      [0.0, 25.0]
# b      [0.0, 25.0]
# c      [0.0, 25.0]
# d      [0.0, 25.0]
# e      [0.0, 25.0]
# f     [25.0, 50.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.1]
# k    [75.0, 100.1]
# dtype: category
# Categories [4, interval[float64]]: [[0.0, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.1]]
0, như trong các ví dụ trước

Nếu 

print[pd.cut[s, 4, labels=False]]
# a    0
# b    0
# c    0
# d    0
# e    0
# f    0
# g    1
# h    1
# i    2
# j    3
# k    3
# dtype: int64
1, chỉ mục số nguyên [số thứ tự bắt đầu từ 0] được sử dụng làm nhãn

print[pd.cut[s, 4, labels=False]]
# a    0
# b    0
# c    0
# d    0
# e    0
# f    0
# g    1
# h    1
# i    2
# j    3
# k    3
# dtype: int64

nguồn.

Bạn cũng có thể chỉ định danh sách bất kỳ nhãn nào. Lưu ý rằng sẽ xảy ra lỗi nếu số lượng ngăn không khớp với số lượng phần tử trong danh sách

print[pd.cut[s, 4, labels=['small', 'medium', 'large', 'x-large']]]
# a      small
# b      small
# c      small
# d      small
# e      small
# f      small
# g     medium
# h     medium
# i      large
# j    x-large
# k    x-large
# dtype: category
# Categories [4, object]: [small < medium < large < x-large]

nguồn.

Chỉ định độ chính xác của các giá trị biên. 
print[pd.cut[s, [0, 10, 50, 100]]]
# a          NaN
# b      [0, 10]
# c      [0, 10]
# d      [0, 10]
# e     [10, 50]
# f     [10, 50]
# g     [10, 50]
# h     [10, 50]
# i    [50, 100]
# j    [50, 100]
# k    [50, 100]
# dtype: category
# Categories [3, interval[int64]]: [[0, 10] < [10, 50] < [50, 100]]
9

Bạn có thể chỉ định độ chính xác [số vị trí thập phân] của các giá trị ranh giới với tham số 

print[pd.cut[s, [0, 10, 50, 100]]]
# a          NaN
# b      [0, 10]
# c      [0, 10]
# d      [0, 10]
# e     [10, 50]
# f     [10, 50]
# g     [10, 50]
# h     [10, 50]
# i    [50, 100]
# j    [50, 100]
# k    [50, 100]
# dtype: category
# Categories [3, interval[int64]]: [[0, 10] < [10, 50] < [50, 100]]
9

print[pd.cut[s, 3]]
# a      [-0.1, 33.333]
# b      [-0.1, 33.333]
# c      [-0.1, 33.333]
# d      [-0.1, 33.333]
# e      [-0.1, 33.333]
# f      [-0.1, 33.333]
# g    [33.333, 66.667]
# h    [33.333, 66.667]
# i    [33.333, 66.667]
# j     [66.667, 100.0]
# k     [66.667, 100.0]
# dtype: category
# Categories [3, interval[float64]]: [[-0.1, 33.333] < [33.333, 66.667] < [66.667, 100.0]]

print[pd.cut[s, 3, precision=1]]
# a     [-0.1, 33.3]
# b     [-0.1, 33.3]
# c     [-0.1, 33.3]
# d     [-0.1, 33.3]
# e     [-0.1, 33.3]
# f     [-0.1, 33.3]
# g     [33.3, 66.7]
# h     [33.3, 66.7]
# i     [33.3, 66.7]
# j    [66.7, 100.0]
# k    [66.7, 100.0]
# dtype: category
# Categories [3, interval[float64]]: [[-0.1, 33.3] < [33.3, 66.7] < [66.7, 100.0]]

nguồn.

Binning để làm cho số phần tử bằng nhau. 
s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
0

print[pd.cut[s, 4, labels=False]]
# a    0
# b    0
# c    0
# d    0
# e    0
# f    0
# g    1
# h    1
# i    2
# j    3
# k    3
# dtype: int64
5 phân chia dữ liệu sao cho số phần tử trong mỗi ngăn bằng nhau nhất có thể

Tham số đầu tiên 

s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
5 là mảng một chiều [danh sách Python hoặc 
s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
6, 
s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
2] làm dữ liệu nguồn và tham số thứ hai 
print[pd.cut[s, 4, labels=False]]
# a    0
# b    0
# c    0
# d    0
# e    0
# f    0
# g    1
# h    1
# i    2
# j    3
# k    3
# dtype: int64
9 là số lượng thùng

Bạn có thể chỉ định các tham số giống như trong 

print[pd.cut[s, 4, labels=['small', 'medium', 'large', 'x-large']]]
# a      small
# b      small
# c      small
# d      small
# e      small
# f      small
# g     medium
# h     medium
# i      large
# j    x-large
# k    x-large
# dtype: category
# Categories [4, object]: [small < medium < large < x-large]
0, 
print[pd.cut[s, [0, 10, 50, 100]]]
# a          NaN
# b      [0, 10]
# c      [0, 10]
# d      [0, 10]
# e     [10, 50]
# f     [10, 50]
# g     [10, 50]
# h     [10, 50]
# i    [50, 100]
# j    [50, 100]
# k    [50, 100]
# dtype: category
# Categories [3, interval[int64]]: [[0, 10] < [10, 50] < [50, 100]]
8 và 
print[pd.cut[s, [0, 10, 50, 100]]]
# a          NaN
# b      [0, 10]
# c      [0, 10]
# d      [0, 10]
# e     [10, 50]
# f     [10, 50]
# g     [10, 50]
# h     [10, 50]
# i    [50, 100]
# j    [50, 100]
# k    [50, 100]
# dtype: category
# Categories [3, interval[int64]]: [[0, 10] < [10, 50] < [50, 100]]
6

Chỉ định số lượng thùng

Bạn có thể chỉ định số lượng phân chia trong 

print[pd.cut[s, 4, labels=False]]
# a    0
# b    0
# c    0
# d    0
# e    0
# f    0
# g    1
# h    1
# i    2
# j    3
# k    3
# dtype: int64
9

Nếu 

print[pd.cut[s, 4, labels=['small', 'medium', 'large', 'x-large']]]
# a      small
# b      small
# c      small
# d      small
# e      small
# f      small
# g     medium
# h     medium
# i      large
# j    x-large
# k    x-large
# dtype: category
# Categories [4, object]: [small < medium < large < x-large]
4, dữ liệu được chia cho 2 phân vị [trung vị]

print[pd.qcut[s, 2]]
# a    [-0.001, 25.0]
# b    [-0.001, 25.0]
# c    [-0.001, 25.0]
# d    [-0.001, 25.0]
# e    [-0.001, 25.0]
# f    [-0.001, 25.0]
# g     [25.0, 100.0]
# h     [25.0, 100.0]
# i     [25.0, 100.0]
# j     [25.0, 100.0]
# k     [25.0, 100.0]
# dtype: category
# Categories [2, interval[float64]]: [[-0.001, 25.0] < [25.0, 100.0]]

nguồn.

Nếu 

print[pd.cut[s, 4, labels=['small', 'medium', 'large', 'x-large']]]
# a      small
# b      small
# c      small
# d      small
# e      small
# f      small
# g     medium
# h     medium
# i      large
# j    x-large
# k    x-large
# dtype: category
# Categories [4, object]: [small < medium < large < x-large]
5, dữ liệu được chia cho 4-phân vị [phần tư]

s_qcut, bins = pd.qcut[s, 4, labels=['Q1', 'Q2', 'Q3', 'Q4'], retbins=True]
print[s_qcut]
# a    Q1
# b    Q1
# c    Q1
# d    Q2
# e    Q2
# f    Q2
# g    Q3
# h    Q3
# i    Q4
# j    Q4
# k    Q4
# dtype: category
# Categories [4, object]: [Q1 < Q2 < Q3 < Q4]

print[bins]
# [  0.    6.5  25.   56.5 100. ]

nguồn.

Đối với các giá trị trùng lặp

Cẩn thận khi có các phần tử trùng lặp trong dữ liệu gốc

Ví dụ: nếu các giá trị được nhân đôi lên đến trung bình

s_cut = pd.cut[s, 4]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[type[s_cut]]
#
0

nguồn.

Có thể chia cho 2 ở trung vị là 

print[pd.cut[s, 4, labels=['small', 'medium', 'large', 'x-large']]]
# a      small
# b      small
# c      small
# d      small
# e      small
# f      small
# g     medium
# h     medium
# i      large
# j    x-large
# k    x-large
# dtype: category
# Categories [4, object]: [small < medium < large < x-large]
4, nhưng số lượng chia nhiều hơn sẽ dẫn đến lỗi

s_cut = pd.cut[s, 4]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[type[s_cut]]
#
1

nguồn.

Ví dụ: trong trường hợp có 4 phần chia, các giá trị tối thiểu, 25%, 50%, 75% và tối đa được đặt làm giá trị biên, nhưng nếu có nhiều phần tử chồng chéo như trong ví dụ thì giá trị tối thiểu và 25% là

Nếu 

print[pd.cut[s, 4, labels=['small', 'medium', 'large', 'x-large']]]
# a      small
# b      small
# c      small
# d      small
# e      small
# f      small
# g     medium
# h     medium
# i      large
# j    x-large
# k    x-large
# dtype: category
# Categories [4, object]: [small < medium < large < x-large]
7, các giá trị ranh giới trùng lặp sẽ bị loại trừ

s_cut = pd.cut[s, 4]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[type[s_cut]]
#
2

nguồn.

Đếm số phần tử trong thùng. 
s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
1

Bạn có thể lấy số phần tử trong một thùng bằng cách gọi phương thức 

s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
1 từ phương thức 
s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
2 được trả về bởi 
print[pd.cut[s, 4, labels=['small', 'medium', 'large', 'x-large']]]
# a      small
# b      small
# c      small
# d      small
# e      small
# f      small
# g     medium
# h     medium
# i      large
# j    x-large
# k    x-large
# dtype: category
# Categories [4, object]: [small < medium < large < x-large]
0 hoặc 
print[pd.cut[s, 4, labels=False]]
# a    0
# b    0
# c    0
# d    0
# e    0
# f    0
# g    1
# h    1
# i    2
# j    3
# k    3
# dtype: int64
5

  • gấu trúc. Loạt. value_counts — gấu trúc 1. 4. 3 tài liệu

s_cut = pd.cut[s, 4]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[type[s_cut]]
#
3

nguồn. 

s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
1 cũng được cung cấp dưới dạng hàm 
print[pd.cut[s, 3]]
# a      [-0.1, 33.333]
# b      [-0.1, 33.333]
# c      [-0.1, 33.333]
# d      [-0.1, 33.333]
# e      [-0.1, 33.333]
# f      [-0.1, 33.333]
# g    [33.333, 66.667]
# h    [33.333, 66.667]
# i    [33.333, 66.667]
# j     [66.667, 100.0]
# k     [66.667, 100.0]
# dtype: category
# Categories [3, interval[float64]]: [[-0.1, 33.333] < [33.333, 66.667] < [66.667, 100.0]]

print[pd.cut[s, 3, precision=1]]
# a     [-0.1, 33.3]
# b     [-0.1, 33.3]
# c     [-0.1, 33.3]
# d     [-0.1, 33.3]
# e     [-0.1, 33.3]
# f     [-0.1, 33.3]
# g     [33.3, 66.7]
# h     [33.3, 66.7]
# i     [33.3, 66.7]
# j    [66.7, 100.0]
# k    [66.7, 100.0]
# dtype: category
# Categories [3, interval[float64]]: [[-0.1, 33.3] < [33.3, 66.7] < [66.7, 100.0]]
4

s_cut = pd.cut[s, 4]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[type[s_cut]]
#
4

nguồn.

Liên kết được tài trợ

Đối với danh sách Python và mảng NumPy

Các ví dụ trước đã sử dụng 

s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
2 làm dữ liệu nguồn, nhưng tham số đầu tiên 
s_cut, bins = pd.cut[s, 4, retbins=True]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[bins]
print[type[bins]]
# [ -0.1  25.   50.   75.  100. ]
#
5 của 
print[pd.cut[s, 4, labels=['small', 'medium', 'large', 'x-large']]]
# a      small
# b      small
# c      small
# d      small
# e      small
# f      small
# g     medium
# h     medium
# i      large
# j    x-large
# k    x-large
# dtype: category
# Categories [4, object]: [small < medium < large < x-large]
0 hoặc 
print[pd.cut[s, 4, labels=False]]
# a    0
# b    0
# c    0
# d    0
# e    0
# f    0
# g    1
# h    1
# i    2
# j    3
# k    3
# dtype: int64
5 có thể là danh sách Python hoặc mảng NumPy 
print[pd.cut[s, 3]]
# a      [-0.1, 33.333]
# b      [-0.1, 33.333]
# c      [-0.1, 33.333]
# d      [-0.1, 33.333]
# e      [-0.1, 33.333]
# f      [-0.1, 33.333]
# g    [33.333, 66.667]
# h    [33.333, 66.667]
# i    [33.333, 66.667]
# j     [66.667, 100.0]
# k     [66.667, 100.0]
# dtype: category
# Categories [3, interval[float64]]: [[-0.1, 33.333] < [33.333, 66.667] < [66.667, 100.0]]

print[pd.cut[s, 3, precision=1]]
# a     [-0.1, 33.3]
# b     [-0.1, 33.3]
# c     [-0.1, 33.3]
# d     [-0.1, 33.3]
# e     [-0.1, 33.3]
# f     [-0.1, 33.3]
# g     [33.3, 66.7]
# h     [33.3, 66.7]
# i     [33.3, 66.7]
# j    [66.7, 100.0]
# k    [66.7, 100.0]
# dtype: category
# Categories [3, interval[float64]]: [[-0.1, 33.3] < [33.3, 66.7] < [66.7, 100.0]]
9 nếu nó là một chiều

s_cut = pd.cut[s, 4]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[type[s_cut]]
#
5

nguồn.

Bạn có thể lấy các phần tử theo chỉ mục và chuyển đổi chúng thành danh sách Python với 

print[pd.qcut[s, 2]]
# a    [-0.001, 25.0]
# b    [-0.001, 25.0]
# c    [-0.001, 25.0]
# d    [-0.001, 25.0]
# e    [-0.001, 25.0]
# f    [-0.001, 25.0]
# g     [25.0, 100.0]
# h     [25.0, 100.0]
# i     [25.0, 100.0]
# j     [25.0, 100.0]
# k     [25.0, 100.0]
# dtype: category
# Categories [2, interval[float64]]: [[-0.001, 25.0] < [25.0, 100.0]]
0

s_cut = pd.cut[s, 4]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[type[s_cut]]
#
6

nguồn.

Nếu bạn muốn đếm số phần tử trong thùng, hãy sử dụng 

print[pd.cut[s, 3]]
# a      [-0.1, 33.333]
# b      [-0.1, 33.333]
# c      [-0.1, 33.333]
# d      [-0.1, 33.333]
# e      [-0.1, 33.333]
# f      [-0.1, 33.333]
# g    [33.333, 66.667]
# h    [33.333, 66.667]
# i    [33.333, 66.667]
# j     [66.667, 100.0]
# k     [66.667, 100.0]
# dtype: category
# Categories [3, interval[float64]]: [[-0.1, 33.333] < [33.333, 66.667] < [66.667, 100.0]]

print[pd.cut[s, 3, precision=1]]
# a     [-0.1, 33.3]
# b     [-0.1, 33.3]
# c     [-0.1, 33.3]
# d     [-0.1, 33.3]
# e     [-0.1, 33.3]
# f     [-0.1, 33.3]
# g     [33.3, 66.7]
# h     [33.3, 66.7]
# i     [33.3, 66.7]
# j    [66.7, 100.0]
# k    [66.7, 100.0]
# dtype: category
# Categories [3, interval[float64]]: [[-0.1, 33.3] < [33.3, 66.7] < [66.7, 100.0]]
4

s_cut = pd.cut[s, 4]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[type[s_cut]]
#
7

nguồn.

Thí dụ. dữ liệu Titanic

Sử dụng dữ liệu Titanic làm ví dụ. Bạn có thể tải xuống từ Kaggle

Nó cũng có sẵn ở đây

  • titanic_train. csv

Một số cột bị loại trừ

s_cut = pd.cut[s, 4]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[type[s_cut]]
#
8

nguồn.

Bin the 

print[pd.qcut[s, 2]]
# a    [-0.001, 25.0]
# b    [-0.001, 25.0]
# c    [-0.001, 25.0]
# d    [-0.001, 25.0]
# e    [-0.001, 25.0]
# f    [-0.001, 25.0]
# g     [25.0, 100.0]
# h     [25.0, 100.0]
# i     [25.0, 100.0]
# j     [25.0, 100.0]
# k     [25.0, 100.0]
# dtype: category
# Categories [2, interval[float64]]: [[-0.001, 25.0] < [25.0, 100.0]]
2 cột với 
print[pd.cut[s, 4, labels=['small', 'medium', 'large', 'x-large']]]
# a      small
# b      small
# c      small
# d      small
# e      small
# f      small
# g     medium
# h     medium
# i      large
# j    x-large
# k    x-large
# dtype: category
# Categories [4, object]: [small < medium < large < x-large]
0

s_cut = pd.cut[s, 4]
print[s_cut]
# a     [-0.1, 25.0]
# b     [-0.1, 25.0]
# c     [-0.1, 25.0]
# d     [-0.1, 25.0]
# e     [-0.1, 25.0]
# f     [-0.1, 25.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.0]
# k    [75.0, 100.0]
# dtype: category
# Categories [4, interval[float64]]: [[-0.1, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.0]]

print[type[s_cut]]
#
9

nguồn.

Để thêm kết quả dưới dạng một cột mới vào bản gốc 

print[pd.qcut[s, 2]]
# a    [-0.001, 25.0]
# b    [-0.001, 25.0]
# c    [-0.001, 25.0]
# d    [-0.001, 25.0]
# e    [-0.001, 25.0]
# f    [-0.001, 25.0]
# g     [25.0, 100.0]
# h     [25.0, 100.0]
# i     [25.0, 100.0]
# j     [25.0, 100.0]
# k     [25.0, 100.0]
# dtype: category
# Categories [2, interval[float64]]: [[-0.001, 25.0] < [25.0, 100.0]]
4, hãy làm như sau. Để ghi đè lên một cột hiện có, chỉ cần đặt tên cột bên trái là tên cột hiện có

print[pd.cut[s, [0, 10, 50, 100]]]
# a          NaN
# b      [0, 10]
# c      [0, 10]
# d      [0, 10]
# e     [10, 50]
# f     [10, 50]
# g     [10, 50]
# h     [10, 50]
# i    [50, 100]
# j    [50, 100]
# k    [50, 100]
# dtype: category
# Categories [3, interval[int64]]: [[0, 10] < [10, 50] < [50, 100]]
0

nguồn.

Lưu ý rằng, trong ví dụ này, quy trình tạo hộp được thực hiện ngay lập tức để thuận tiện, nhưng lý tưởng nhất là giá trị còn thiếu 

print[pd.cut[s, 4, right=False]]
# a      [0.0, 25.0]
# b      [0.0, 25.0]
# c      [0.0, 25.0]
# d      [0.0, 25.0]
# e      [0.0, 25.0]
# f     [25.0, 50.0]
# g     [25.0, 50.0]
# h     [25.0, 50.0]
# i     [50.0, 75.0]
# j    [75.0, 100.1]
# k    [75.0, 100.1]
# dtype: category
# Categories [4, interval[float64]]: [[0.0, 25.0] < [25.0, 50.0] < [50.0, 75.0] < [75.0, 100.1]]
3 phải được bổ sung trước khi tạo hộp

Binning trong Python là gì?

Làm mịn bằng phương tiện bin. Khi làm mịn bằng phương tiện bin, mỗi giá trị trong một ngăn được thay thế bằng giá trị trung bình của ngăn . Làm mịn bằng trung vị bin. Trong phương pháp này, mỗi giá trị bin được thay thế bằng giá trị trung bình bin của nó.

Dữ liệu bin trong Python có nghĩa là gì?

Khai thác dữ liệu là một loại tiền xử lý dữ liệu, một cơ chế bao gồm cả việc xử lý các giá trị bị thiếu, định dạng, chuẩn hóa và tiêu chuẩn hóa . Binning có thể được áp dụng để chuyển đổi các giá trị số thành giá trị số phân loại hoặc mẫu [lượng tử hóa].

Binning trong gấu trúc là gì?

Binning còn được gọi là chia nhóm hoặc rời rạc hóa là một kỹ thuật xử lý trước dữ liệu phổ biến được sử dụng để nhóm các khoảng dữ liệu liên tục thành “thùng” hoặc “nhóm”. In this article we will discuss 4 methods for binning numerical values using python Pandas library.

Mục đích của việc tạo thùng là gì?

Binning, còn được gọi là phân tách, là một kỹ thuật để giảm số lượng bản số của dữ liệu rời rạc và liên tục . Ghép nhóm các giá trị liên quan lại với nhau trong các thùng để giảm số lượng các giá trị riêng biệt.

Bài Viết Liên Quan

Làm cách nào để buộc tải xuống một tệp bằng JavaScript?
Khung xác thực dữ liệu python
Chọn bảng mysql
Làm cách nào để tạo bảng tính trong php?
Cách tham dự CES 2023
Sigusr1 trong python là gì?
Vũng Tàu đi Phan Thiết bao nhiêu km
Python có chậm hơn java không?
Tôi có thể sử dụng phạm vi trong vòng lặp while trong Python không?
Chức năng python có thể sửa đổi đối số không?
Làm cách nào để chuyển đổi tệp PHP sang XML?
Máy tính chẵn Python
Chuỗi độc đáo python
Giá trị tối đa trong từ điển Python
CSS không hoạt động
Thông báo'': Bảo vệ xác thực (api) không được xác định.'', ngoại lệ'': InvalidArgumentException
Phát biểu nào không đúng về PHP?
Gỡ lỗi php trong văn bản cao siêu
Làm cách nào để giải quyết lỗi API không dùng nữa trong Java?
Flagstaff AZ mức lương tối thiểu 2023

Toplist mới

#1
Top 7 sự tích hồ gươm - ngữ văn lớp 6 2023
6 tháng trước
#2
Top 7 gdcd 6 bài 1 kết nối tri thức 2023
6 tháng trước
#3
Top 7 ý nghĩa của xây dựng gia đình văn hóa 2023
6 tháng trước
#4
Top 6 mẫu hợp đồng mượn đất làm nhà xưởng 2023
6 tháng trước
#5
Top 3 tổng tài biến thái tôi yêu anh tập 27 2023
6 tháng trước
#6
Top 6 kết thực phim mỹ nhân vô lệ 2023
6 tháng trước
#7
Top 9 trong những câu thơ sau câu nào sử dụng thành ngữ 2023
6 tháng trước
#8
Top 8 đề tài và chủ de của tác phẩm tắt đèn 2023
6 tháng trước
#9
Top 5 tiểu sử của thầy thích pháp hòa 2023
6 tháng trước

Bài mới nhất

Hạt giống nguyên chủng là gì năm 2024
De thi học kì 1 hóa 9 tphcm năm 2024
Hay mộng tinh là bệnh gì năm 2024
Phục hồi nút erase trong cs6 bị lỗi năm 2024
Nhung loai rau cu tot cho gan và tiên hóa năm 2024
Dì ruột bán cháu ở thường xuân thanh hóa năm 2024
Thu nhập trung bình của quản lý nhà hàng năm 2024
Kiến bu quần lót là hiện tượng gì năm 2024

Chủ Đề

programming Hỏi Đáp Toplist Là gì Bài Tập Địa Điểm Hay Mẹo Hay Học Tốt Nghĩa của từ Công Nghệ Khỏe Đẹp bao nhiêu Top List Tiếng anh Bao nhiêu Sản phẩm tốt Xây Đựng Ngôn ngữ javascript Ở đâu Đại học Hướng dẫn Bài tập Tại sao Dịch So Sánh Máy tính Món Ngon mẹo hay Bao lâu Thế nào So sánh Khoa Học Vì sao Lớp 9 Lớp 10