Nhảy tới nội dung

Các hàm và phương thức khác

Phương thức lấy Series []​

Sử dụng [<tên cột>] để lấy 1 Series của bảng. Ví dụ để lấy Series của cột department ta làm như sau

df['department']
0         1
1         1
2         1
3         1
4         1
         ..
10769    99
10770    99
10771    99
10772    99
10773    99
Name: department, Length: 10774, dtype: int64

những Series này cũng có thế áp dụng các phương thức tương tự của DataFrame như .head(), .tail()....

Phương thức ép kiểu .astype()​

Với phương thức .astype() ta có thể ép kiểu dữ liệu của cột về dạng khác. Việc ép kiểu này giúp thay đổi kiểu dữ liệu để tiện các thao tác như nối 2 cột có 2 kiểu str và int, ngoài ra việc ép kiểu cũng giúp giảm được dung lượng bộ nhớ dành cho bảng.

Ở ví dụ trên, ta thấy cột department có giá trị max là 99 nhưng được mặc định là int64 khá lãng phí, do đó ép kiểu về int8

Trước khi ép kiểu

df['department'].dtypes
dtype('int64')
 
df['department'].memory_usage() - df['department'].index.memory_usage()
86192

Sau khi ép kiểu

df['department'].astype('int8').memory_usage() - df['department'].index.memory_usage()
10774

Ta thấy sau khi ép kiểu thì bộ nhớ lưu trữ của cột department giảm đi 8 lần.

Lưu ý

df['department'].memory_usage() trả về dung lượng lưu trữ của cột department và dung lượng lưu trữ của index

Phương thức loại bỏ các dòng trùng lặp .drop_duplicates()​

Phương thức này trả về DataFrame đã được loại bỏ các hàng trùng nhau. Lệnh thực hiện

DataFrame.drop_duplicates(subset=None, keep='first', inplace=False, ignore_index=False)

Trong đó:

  • subset: tên cột hoặc danh sách các cột cần lọc giá trị trùng lặp, nếu không truyền vào sẽ mặc định chọn tất cả các cột

  • keep: các kiểu lọc duplicate bao gồm các lựa chọn sau:

    • 'first': loại bỏ các dòng bản sao, chỉ giữ lại dòng đầu tiên
    • 'last': loại bỏ các dòng bản sao, chỉ giữ lại dòng cuối cùng
    • False: loại tất cả các dòng trùng lặp

  • inplace: thao tác trực tiếp trên bảng nếu để giá trị True hoặc tạo 1 bản sao với giá trị False

  • ignore_index: Nếu True trả về index đánh số lại từ 0 đến n-1

Ví dụ

df = pd.DataFrame({
    'action': ['view', 'view', 'add to cart', 'add to cart', 'add to cart',],
    'fruit': ['orange', 'orange', 'orange', 'apple', 'apple'],
    'times':   [ 1, 1, 3, 2, 4]
})
df
        action  fruit   times
0         view  orange      1
1         view  orange      1
2  add to cart  orange      3
3  add to cart   apple      2
4  add to cart   apple      4
 
df.drop_duplicates()
        action  fruit   times
0         view  orange      1
2  add to cart  orange      3
3  add to cart   apple      2
4  add to cart   apple      4
 
df.drop_duplicates(subset=['action'])
        action  fruit   times
0         view  orange      1
2  add to cart  orange      3
df.drop_duplicates(subset=['action','fruit'], keep='last', ignore_index=True)
        action   fruit  times
0         view  orange      1
1  add to cart  orange      3
2  add to cart   apple      4

Phương thức đếm số lần xuất hiện .value_counts()​

Phương thức này trả số lần xuất hiện của các phần tử trong Series. Kết quả trả về mặc định sẽ sắp xếp theo số lần xuất hiện giảm dần và mặc định bỏ qua các giá trị null

Series.value_counts(normalize=False, sort=True, ascending=False, bins=None, dropna=True)

Trong đó:

  • normalize: True sẽ trả về tỉ lệ xuất hiện của các phần tử

  • sort: True sẽ trả về kết quả sắp xếp theo số lần xuất hiện, False sẽ trả về kết quả sắp xếp theo trình tự xuất hiện của phần tử

  • ascending: True sẽ trả về kết quả sắp xếp theo số lần xuất hiện tăng dần.

  • bins: gom nhóm các phần tử, tương tự pd.cut

  • dropna: False sẽ đếm tất cả các phần tử kể cả null

Ví dụ

s = pd.Series([3, 1, 2, 3,  np.nan, 4, np.nan])
s.value_counts()
3.0    2
1.0    1
2.0    1
4.0    1
dtype: int64
s.value_counts(normalize=True, sort=False, dropna=False)
3.0    0.285714
1.0    0.142857
2.0    0.142857
NaN    0.285714
4.0    0.142857
dtype: float64
 
s.value_counts(bins=3)
(0.996, 2.0]    2
(2.0, 3.0]      2
(3.0, 4.0]      1
dtype: int64

Phương thức lấy các giá trị khác nhau .unique() và .nunique()​

Phương thức .unique() trả về các giá trị khác nhau của Series và .nunique() trả về số lượng các giá trị khác nhau của Series. Kết quả trả về của .unique() là danh sách các phần tử được sắp xếp theo thứ tự đầu vào của bảng. Để loại bỏ giá trị NA trong lúc đếm có thể gọi .nunique(dropna=False)

Cách sử dụng

s = pd.Series([2, 3, 1 ,2, np.nan], name='col_0')
s
0    2.0
1    3.0
2    1.0
3    2.0
4    NaN
Name: col_0, dtype: float64
 
s.unique()
array([ 2.,  3.,  1., nan])
 
s.nunique(dropna=False)
4

Phương thức loại bỏ các dòng hoặc cột .drop()​

Phương thức .drop() dùng để loại bỏ các dòng hoặc cột theo chỉ định. Cú pháp của .drop() như sau

DataFrame.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')

Trong đó:

  • labels: Tên cột hoặc dòng cần loại bỏ.

  • axis: Mặc đinh giá trị 0 loại bỏ theo dòng và 1 loại bỏ theo cột.

  • index: Chỉ định index của dòng cần loại bỏ, tương đương labels, axis=0

  • columns: Chỉ định cột cần loại bỏ, tương đương labels, axis=1

  • level: Dành cho MultiIndex, khi đó chỉ định cấp độ index cần loại bỏ

  • inplace: Thực hiện trên chính bảng hay tạo ra một bảng sao

  • errors: mặc định raise sẽ trả ra lỗi và ignore nếu muốn bỏ qua lỗi.

Ví dụ

df = pd.DataFrame(np.arange(16).reshape(4, 4),
                  columns=['A', 'B', 'C', 'D'],
                  index=['A', '1A', '2A', '3A'])
df
     A   B   C   D
A    0   1   2   3
1A   4   5   6   7
2A   8   9  10  11
3A  12  13  14  15
 
df.drop('A')
	A	B	C	D
1A	4	5	6	7
2A	8	9	10	11
3A	12	13	14	15
 
df.drop(columns=['A', 'C'])
     B   D
A    1   3
1A   5   7
2A   9  11
3A  13  15
 
df.drop(index=['A', '2A'])
     A   B   C   D
1A   4   5   6   7
3A  12  13  14  15
Lưu ý

Thực tế hay dùng các params columns và index để chỉ định các dòng hay cột cần được loại bỏ hơn là dùng labels và axis

Phương thức đổi tên cột hoặc dòng .rename()​

Phương thức .rename() dùng để đổi tên nhãn của cột hoặc dòng. Cú pháp như sau

DataFrame.rename(mapper=None, *, index=None, columns=None, axis=None, copy=True, inplace=False, level=None, errors='ignore')[source]

Trong đó:

  • mapper: là một danh sách dạng dictionary chứa key là tên cần đổi và value là tên mới.

  • axis: Mặc đinh giá trị 0 thay đổi theo index và 1 thay đổi theo cột.

  • index: Chỉ định index của dòng cần thay đổi, tương đương mapper, axis=0, thay thế bằng index=mapper

  • columns: Chỉ định cột cần thay đổi, tương đương mapper, axis=1, thay thế bằng columns=mapper

  • copy: True, mặc định sao chép dữ liệu

  • level: Dành cho MultiIndex, khi đó chỉ định cấp độ index cần đổi tên

  • inplace: Thực hiện trên chính bảng hay tạo ra một bảng sao

  • errors: mặc định raise sẽ trả ra lỗi và ignore nếu muốn bỏ qua lỗi.

Ví dụ

df = pd.DataFrame(np.arange(16).reshape(4, 4),
                        columns=['A', 'B', 'C', 'D'],
                        index=['A', '1A', '2A', '3A'])
df.rename(mapper={'A':'aA'})
     A   B   C   D
aA   0   1   2   3
1A   4   5   6   7
2A   8   9  10  11
3A  12  13  14  15
 
df.rename(mapper={'A':'aA'}, axis=1)
    aA   B   C   D
A    0   1   2   3
1A   4   5   6   7
2A   8   9  10  11
3A  12  13  14  15
 
df.rename(columns={'A':'aA', 'B':'Bb'}, index={'A': 'OA','3A':'3a'})
    aA  Bb   C   D
OA   0   1   2   3
1A   4   5   6   7
2A   8   9  10  11
3a  12  13  14  15
Lưu ý

Tương tự như .drop() thì columns và index thường được sử dụng hơn là mapper và axis.

Vẫn chưa rõ copy dùng để làm gì.

Phương thức chuyển đổi cột thành index .set_index()​

Phương thức .set_index() dùng để chuyển đổi một cột của bảng thành index. Index này có thể thay thể index cũ hoặc thêm vào để thành MultiIndex. Cách sử dụng như sau:

DataFrame.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=False)

Trong đó:

  • keys: Có thể truyền vào một cột duy nhất hoặc danh sách các cột. Ngoài ra còn có thể là 1 danh sách dạng pd.Index, Series, np.array, iterator

  • drop: loại bỏ cột trong bảng nếu đã đưa vào index, mặc định là True

  • append: mặc định là False ghi đè lên index đã có. Giá trị True sẽ thêm vào index sẵn có.

  • inplace: Thực hiện trực tiếp trên bảng hoặc tạo ra một bản sao

  • verify_integrity: Kiểm tra xem cột đánh index có chứa các phần tử trùng lặp hay không.

Ví dụ

df = pd.DataFrame(np.arange(16).reshape(4, 4),
                  columns=['A', 'B', 'C', 'D'],
                  index=['A', '1A', '2A', '3A'])
df.index.name = 'index1'
df
         A   B   C   D
index1                
A        0   1   2   3
1A       4   5   6   7
2A       8   9  10  11
3A      12  13  14  15
 
df.set_index('A')
     B   C   D
A             
0    1   2   3
4    5   6   7
8    9  10  11
12  13  14  15
 
df.set_index(['A', 'B'], append=True)
               C   D
index1 A  B         
A      0  1    2   3
1A     4  5    6   7
2A     8  9   10  11
3A     12 13  14  15
 
df.set_index([pd.Index([1, 2, 3, 4], name='new_index')])
            A   B   C   D
new_index                
1           0   1   2   3
2           4   5   6   7
3           8   9  10  11
4          12  13  14  15
Lưu ý

keys không áp dụng cho kiểu list, tuple nhưng Iterator của nó thì được.

Ví dụ khi đưa list vào sẽ báo lỗi

df.set_index([1, 2, 3, 4])
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_1380/3577861036.py in <module>
----> 1 df.set_index([1, 2, 3, 4])

D:\Vendors\anaconda\lib\site-packages\pandas\util\_decorators.py in wrapper(*args, **kwargs)
    309                     stacklevel=stacklevel,
    310                 )
--> 311             return func(*args, **kwargs)
    312 
    313         return wrapper

D:\Vendors\anaconda\lib\site-packages\pandas\core\frame.py in set_index(self, keys, drop, append, inplace, verify_integrity)
   5492 
   5493         if missing:
-> 5494             raise KeyError(f"None of {missing} are in the columns")
   5495 
   5496         if inplace:

KeyError: 'None of [1, 2, 3, 4] are in the columns'

Trong khi đưa vào Iterator thì hoạt động.

df.set_index(iter([1, 2, 3, 4]))
    A   B   C   D
1   0   1   2   3
2   4   5   6   7
3   8   9  10  11
4  12  13  14  15

Phương thức sắp xếp .sort_values​

Phương thức .sort_values dùng để sắp xếp dữ liệu trong DataFrame hoặc Series

DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last', ignore_index=False, key=None)

Trong đó:

  • by : nhãn hoặc danh sách nhãn cần sắp xếp

  • axis: chỉ định chiều sắp xếp { 0 hoặc index, 1 hoặc columns }

  • ascending: Sắp xếp tăng dần hoặc giảm dần, có thể là một giá trị hoặc danh sách các giá trị boolean

  • inplace: Thực hiện trên chính bảng đó hoặc tạo ra một bản sao

  • kind: Thuật toán sắp xếp

  • na_postion: chỉ định các giá trị NA được xếp đầu hoặc cuôi

  • ignore_index: Nếu để giá trị True sẽ thực hiện đánh index lại từ 0

  • key: key function

df = pd.DataFrame({
    'col1': ['A', 'A', 'B', np.nan, 'D', 'C'],
    'col2': [2, 1, 9, 8, 2, 4],
    'col3': [0, 1, 9, 4, 2, 3],
    'col4': ['a', 'B', 'c', 'D', 'e', 'F']
})
df
  col1  col2  col3 col4
0    A     2     0    a
1    A     1     1    B
2    B     9     9    c
3  NaN     8     4    D
4    D     2     2    e
5    C     4     3    F

Sắp xếp theo col1

df.sort_values(by=['col1'])
  col1  col2  col3 col4
0    A     2     0    a
1    A     1     1    B
2    B     9     9    c
5    C     4     3    F
4    D     2     2    e
3  NaN     8     4    D

Sắp xếp theo nhiều cột

df.sort_values(by=['col1', 'col2'])
  col1  col2  col3 col4
1    A     1     1    B
0    A     2     0    a
2    B     9     9    c
5    C     4     3    F
4    D     7     2    e
3  NaN     8     4    D

Sắp xếp theo tăng giảm

df.sort_values(by=['col1', 'col2'], ascending=[False, True])
  col1  col2  col3 col4
4    D     2     2    e
5    C     4     3    F
2    B     9     9    c
1    A     1     1    B
0    A     2     0    a
3  NaN     8     4    D

Thay đổi vị trí của NaN

df.sort_values(by='col1', ascending=False, na_position='first')
  col1  col2  col3 col4
3  NaN     8     4    D
4    D     2     2    e
5    C     4     3    F
2    B     9     9    c
0    A     2     0    a
1    A     1     1    B

Sắp xếp với key function

df.sort_values(by='col4', key=lambda col: col.str.lower())
  col1  col2  col3 col4
0    A     2     0    a
1    A     1     1    B
2    B     9     9    c
3  NaN     8     4    D
4    D     2     2    e
5    C     4     3    F