Python thay thế phần tử trong danh sách theo điều kiện

Điều này khác với việc cập nhật với

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

7 hoặc

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

8, yêu cầu bạn chỉ định một vị trí để cập nhật với một số giá trị

Parametersto_replace str, regex, list, dict, Series, int, float hoặc Không

Cách tìm các giá trị sẽ được thay thế

• số, str hoặc regex

  • con số. giá trị số bằng to_replace sẽ được thay thế bằng giá trị

  • str. chuỗi khớp chính xác với to_replace sẽ được thay thế bằng giá trị

  • biểu thức chính quy. biểu thức chính quy khớp với to_replace sẽ được thay thế bằng giá trị

• danh sách str, regex hoặc số

  • Đầu tiên, nếu to_replace và value đều là danh sách, chúng phải có cùng độ dài

  • Thứ hai, nếu

    >>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
    ..                    'B': [5, 6, 7, 8, 9],
    ..                    'C': ['a', 'b', 'c', 'd', 'e']}]
    >>> df.replace[0, 5]
        A  B  C
    0  5  5  a
    1  1  6  b
    2  2  7  c
    3  3  8  d
    4  4  9  e
    

    9 thì tất cả các chuỗi trong cả hai danh sách sẽ được hiểu là biểu thức chính quy nếu không chúng sẽ khớp trực tiếp. Điều này không quan trọng lắm đối với giá trị vì chỉ có một vài biểu thức thay thế khả thi mà bạn có thể sử dụng

  • quy tắc str, regex và số áp dụng như trên

• mệnh lệnh

  • Dicts có thể được sử dụng để chỉ định các giá trị thay thế khác nhau cho các giá trị hiện có khác nhau. Ví dụ:

    >>> df.replace[[0, 1, 2, 3], 4]
        A  B  C
    0  4  5  a
    1  4  6  b
    2  4  7  c
    3  4  8  d
    4  4  9  e
    

    0 thay thế giá trị 'a' bằng 'b' và 'y' bằng 'z'. Để sử dụng lệnh theo cách này, không nên cung cấp tham số giá trị tùy chọn

  • Đối với DataFrame, một lệnh có thể chỉ định rằng các giá trị khác nhau sẽ được thay thế trong các cột khác nhau. Ví dụ:

    >>> df.replace[[0, 1, 2, 3], 4]
        A  B  C
    0  4  5  a
    1  4  6  b
    2  4  7  c
    3  4  8  d
    4  4  9  e
    

    1 tìm kiếm giá trị 1 trong cột 'a' và giá trị 'z' trong cột 'b' và thay thế các giá trị này bằng bất kỳ giá trị nào được chỉ định trong giá trị. Tham số giá trị không nên là

    >>> df.replace[[0, 1, 2, 3], 4]
        A  B  C
    0  4  5  a
    1  4  6  b
    2  4  7  c
    3  4  8  d
    4  4  9  e
    

    2 trong trường hợp này. Bạn có thể coi đây là trường hợp đặc biệt khi chuyển hai danh sách ngoại trừ việc bạn đang chỉ định cột để tìm kiếm trong đó

  • Đối với từ điển lồng nhau DataFrame, e. g. ,

    >>> df.replace[[0, 1, 2, 3], 4]
        A  B  C
    0  4  5  a
    1  4  6  b
    2  4  7  c
    3  4  8  d
    4  4  9  e
    

    3, được đọc như sau. tìm trong cột 'a' cho giá trị 'b' và thay thế nó bằng NaN. Không nên chỉ định tham số giá trị tùy chọn để sử dụng lệnh lồng nhau theo cách này. Bạn cũng có thể lồng các biểu thức chính quy. Lưu ý rằng tên cột [các khóa từ điển cấp cao nhất trong từ điển lồng nhau] không thể là biểu thức chính quy

• Không có

  • Điều này có nghĩa là đối số biểu thức chính quy phải là một chuỗi, biểu thức chính quy được biên dịch hoặc danh sách, dict, ndarray hoặc Chuỗi các phần tử đó. Nếu giá trị cũng là

    >>> df.replace[[0, 1, 2, 3], 4]
        A  B  C
    0  4  5  a
    1  4  6  b
    2  4  7  c
    3  4  8  d
    4  4  9  e
    

    2 thì đây phải là từ điển lồng nhau hoặc Sê-ri

Xem phần ví dụ để biết ví dụ về từng loại này

giá trị vô hướng, dict, danh sách, str, regex, mặc định Không có

Giá trị để thay thế bất kỳ giá trị nào khớp với to_replace bằng. Đối với DataFrame, một lệnh của các giá trị có thể được sử dụng để chỉ định giá trị nào sẽ sử dụng cho mỗi cột [các cột không có trong lệnh sẽ không được điền]. Biểu thức chính quy, chuỗi và danh sách hoặc ký tự của các đối tượng đó cũng được phép

tại chỗ bool, mặc định Sai

Nếu Đúng, thực hiện thao tác tại chỗ và trả về Không có

giới hạn int, mặc định Không có

Khoảng cách kích thước tối đa để lấp đầy về phía trước hoặc phía sau

regex bool hoặc cùng loại với to_replace, mặc định Sai

Có diễn giải to_replace và/hoặc giá trị dưới dạng biểu thức chính quy hay không. Nếu đây là

>>> df.replace[[0, 1, 2, 3], 4]
    A  B  C
0  4  5  a
1  4  6  b
2  4  7  c
3  4  8  d
4  4  9  e

5 thì to_replace phải là một chuỗi. Ngoài ra, đây có thể là một biểu thức chính quy hoặc một danh sách, chính tả hoặc mảng các biểu thức chính quy trong trường hợp to_replace phải là

>>> df.replace[[0, 1, 2, 3], 4]
    A  B  C
0  4  5  a
1  4  6  b
2  4  7  c
3  4  8  d
4  4  9  e

2

phương thức {'pad', 'fill', 'bfill'}

Phương thức sử dụng khi thay thế, khi to_replace là vô hướng, danh sách hoặc bộ và giá trị là

>>> df.replace[[0, 1, 2, 3], 4]
    A  B  C
0  4  5  a
1  4  6  b
2  4  7  c
3  4  8  d
4  4  9  e

2

Đã thay đổi trong phiên bản 0. 23. 0. Đã thêm vào DataFrame.

ReturnsSeries

Đối tượng sau khi thay thế

TăngAssertionError

• Nếu regex không phải là

  >>> df.replace[[0, 1, 2, 3], 4]
      A  B  C
  0  4  5  a
  1  4  6  b
  2  4  7  c
  3  4  8  d
  4  4  9  e
  

  8 và to_replace không phải là

  >>> df.replace[[0, 1, 2, 3], 4]
      A  B  C
  0  4  5  a
  1  4  6  b
  2  4  7  c
  3  4  8  d
  4  4  9  e
  

  2

LoạiLỗi

• Nếu to_replace không phải là vô hướng, dạng mảng,

  >>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
  ..                    'B': [5, 6, 7, 8, 9],
  ..                    'C': ['a', 'b', 'c', 'd', 'e']}]
  >>> df.replace[0, 5]
      A  B  C
  0  5  5  a
  1  1  6  b
  2  2  7  c
  3  3  8  d
  4  4  9  e
  

  30 hoặc

  >>> df.replace[[0, 1, 2, 3], 4]
      A  B  C
  0  4  5  a
  1  4  6  b
  2  4  7  c
  3  4  8  d
  4  4  9  e
  

  2

• Nếu to_replace là một

  >>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
  ..                    'B': [5, 6, 7, 8, 9],
  ..                    'C': ['a', 'b', 'c', 'd', 'e']}]
  >>> df.replace[0, 5]
      A  B  C
  0  5  5  a
  1  1  6  b
  2  2  7  c
  3  3  8  d
  4  4  9  e
  

  30 và giá trị không phải là một

  >>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
  ..                    'B': [5, 6, 7, 8, 9],
  ..                    'C': ['a', 'b', 'c', 'd', 'e']}]
  >>> df.replace[0, 5]
      A  B  C
  0  5  5  a
  1  1  6  b
  2  2  7  c
  3  3  8  d
  4  4  9  e
  

  33,

  >>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
  ..                    'B': [5, 6, 7, 8, 9],
  ..                    'C': ['a', 'b', 'c', 'd', 'e']}]
  >>> df.replace[0, 5]
      A  B  C
  0  5  5  a
  1  1  6  b
  2  2  7  c
  3  3  8  d
  4  4  9  e
  

  30,

  >>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
  ..                    'B': [5, 6, 7, 8, 9],
  ..                    'C': ['a', 'b', 'c', 'd', 'e']}]
  >>> df.replace[0, 5]
      A  B  C
  0  5  5  a
  1  1  6  b
  2  2  7  c
  3  3  8  d
  4  4  9  e
  

  35 hoặc

  >>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
  ..                    'B': [5, 6, 7, 8, 9],
  ..                    'C': ['a', 'b', 'c', 'd', 'e']}]
  >>> df.replace[0, 5]
      A  B  C
  0  5  5  a
  1  1  6  b
  2  2  7  c
  3  3  8  d
  4  4  9  e
  

  36

• Nếu to_replace là

  >>> df.replace[[0, 1, 2, 3], 4]
      A  B  C
  0  4  5  a
  1  4  6  b
  2  4  7  c
  3  4  8  d
  4  4  9  e
  

  2 và regex không thể biên dịch thành biểu thức chính quy hoặc là danh sách, dict, ndarray hoặc Sê-ri

• Khi thay thế nhiều đối tượng

  >>> df.replace[[0, 1, 2, 3], 4]
      A  B  C
  0  4  5  a
  1  4  6  b
  2  4  7  c
  3  4  8  d
  4  4  9  e
  

  8 hoặc

  >>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
  ..                    'B': [5, 6, 7, 8, 9],
  ..                    'C': ['a', 'b', 'c', 'd', 'e']}]
  >>> df.replace[0, 5]
      A  B  C
  0  5  5  a
  1  1  6  b
  2  2  7  c
  3  3  8  d
  4  4  9  e
  

  39 và đối số to_replace không khớp với loại giá trị được thay thế

Giá trịError

• Nếu một

  >>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
  ..                    'B': [5, 6, 7, 8, 9],
  ..                    'C': ['a', 'b', 'c', 'd', 'e']}]
  >>> df.replace[0, 5]
      A  B  C
  0  5  5  a
  1  1  6  b
  2  2  7  c
  3  3  8  d
  4  4  9  e
  

  33 hoặc một

  >>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
  ..                    'B': [5, 6, 7, 8, 9],
  ..                    'C': ['a', 'b', 'c', 'd', 'e']}]
  >>> df.replace[0, 5]
      A  B  C
  0  5  5  a
  1  1  6  b
  2  2  7  c
  3  3  8  d
  4  4  9  e
  

  35 được chuyển đến to_replace và giá trị nhưng chúng không có cùng độ dài

Xem thêm

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

52

Điền giá trị NA

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

53

Thay thế các giá trị dựa trên điều kiện boolean

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

54

Thay dây đơn giản

ghi chú

• Thay thế Regex được thực hiện dưới mui xe với

  >>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
  ..                    'B': [5, 6, 7, 8, 9],
  ..                    'C': ['a', 'b', 'c', 'd', 'e']}]
  >>> df.replace[0, 5]
      A  B  C
  0  5  5  a
  1  1  6  b
  2  2  7  c
  3  3  8  d
  4  4  9  e
  

  55. Các quy tắc thay thế cho

  >>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
  ..                    'B': [5, 6, 7, 8, 9],
  ..                    'C': ['a', 'b', 'c', 'd', 'e']}]
  >>> df.replace[0, 5]
      A  B  C
  0  5  5  a
  1  1  6  b
  2  2  7  c
  3  3  8  d
  4  4  9  e
  

  55 là như nhau

• Các biểu thức chính quy sẽ chỉ thay thế trên các chuỗi, nghĩa là bạn không thể cung cấp, ví dụ: một biểu thức chính quy khớp với các số dấu phẩy động và mong đợi các cột trong khung của bạn có một kiểu số được khớp. Tuy nhiên, nếu các số dấu phẩy động đó là các chuỗi, thì bạn có thể thực hiện việc này

• Phương pháp này có rất nhiều lựa chọn. Bạn được khuyến khích thử nghiệm và chơi với phương pháp này để có được trực giác về cách thức hoạt động của nó

• Khi dict được sử dụng làm giá trị to_replace, nó giống như [các] khóa trong dict là phần to_replace và [các] giá trị trong dict là tham số giá trị

ví dụ

Vô hướng `to_replace` và `value`

>>> df.replace[[0, 1, 2, 3], 4]
    A  B  C
0  4  5  a
1  4  6  b
2  4  7  c
3  4  8  d
4  4  9  e

0

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

Giống như danh sách `to_replace`

>>> df.replace[[0, 1, 2, 3], 4]
    A  B  C
0  4  5  a
1  4  6  b
2  4  7  c
3  4  8  d
4  4  9  e

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

3

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

5

giống như dict `to_replace`

>>> df.replace[[0, 1, 2, 3], 4]
    A  B  C
0  4  5  a
1  4  6  b
2  4  7  c
3  4  8  d
4  4  9  e

5

>>> df.replace[[0, 1, 2, 3], 4]
    A  B  C
0  4  5  a
1  4  6  b
2  4  7  c
3  4  8  d
4  4  9  e

6

>>> df.replace[[0, 1, 2, 3], 4]
    A  B  C
0  4  5  a
1  4  6  b
2  4  7  c
3  4  8  d
4  4  9  e

7

Cụm từ thông dụng `to_replace`

>>> df.replace[[0, 1, 2, 3], 4]
    A  B  C
0  4  5  a
1  4  6  b
2  4  7  c
3  4  8  d
4  4  9  e

8

>>> df.replace[[0, 1, 2, 3], 4]
    A  B  C
0  4  5  a
1  4  6  b
2  4  7  c
3  4  8  d
4  4  9  e

9

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

0

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

1

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

2

So sánh hành vi của

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

57 và

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

58 để hiểu đặc thù của tham số to_replace

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

3

Khi một người sử dụng một dict làm giá trị to_replace, nó giống như [các] giá trị trong dict bằng với tham số giá trị.

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

57 tương đương với

>>> df.replace[[0, 1, 2, 3], 4]
    A  B  C
0  4  5  a
1  4  6  b
2  4  7  c
3  4  8  d
4  4  9  e

50

>>> df = pd.DataFrame[{'A': [0, 1, 2, 3, 4],
..                    'B': [5, 6, 7, 8, 9],
..                    'C': ['a', 'b', 'c', 'd', 'e']}]
>>> df.replace[0, 5]
    A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

4

Khi

>>> df.replace[[0, 1, 2, 3], 4]
    A  B  C
0  4  5  a
1  4  6  b
2  4  7  c
3  4  8  d
4  4  9  e

51 không được chuyển rõ ràng và to_replace là một vô hướng, danh sách hoặc bộ dữ liệu, thay thế sử dụng tham số phương thức [mặc định là 'pad'] để thực hiện thay thế. Vì vậy, đây là lý do tại sao các giá trị 'a' được thay thế bằng 10 ở hàng 1 và 2 và 'b' ở hàng 4 trong trường hợp này