Python中高效实现数据去重的多种方法

### 使用集合去重

集合是Python中用于存储唯一元素的数据结构，可以快速去除列表中的重复项。这种方法简单高效，适用于大多数场景。

```python

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = list(set(data))

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用字典键去重

字典的键具有唯一性，可以利用这一特性去除重复数据。这种方法在保留顺序的同时去重。

```python

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = list(dict.fromkeys(data))

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表推导式与条件判断

通过遍历列表并仅添加未出现过的元素，可以实现去重并保留原始顺序。

```python

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = []

[unique_data.append(x) for x in data if x not in unique_data]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用Pandas库去重

对于大规模数据，Pandas库提供了高效的去重方法，特别适用于处理DataFrame或Series数据。

```python

import pandas as pd

data = [1, 2, 2, 3, 4, 4, 5]

series = pd.Series(data)

unique_data = series.drop_duplicates().tolist()

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用NumPy库去重

NumPy库提供了针对数组的高效去重方法，适用于数值型数据。

```python

import numpy as np

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = np.unique(data).tolist()

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用itertools.groupby去重

如果数据已排序，可以使用itertools.groupby方法去除连续重复项。

```python

from itertools import groupby

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = [key for key, _ in groupby(data)]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表的index方法去重

通过查找元素首次出现的位置，可以保留顺序并去除重复项。

```python

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = [data[i] for i in range(len(data)) if data.index(data[i]) == i]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用collections.OrderedDict去重

OrderedDict可以保留插入顺序，同时利用字典键的唯一性去重。

```python

from collections import OrderedDict

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = list(OrderedDict.fromkeys(data))

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表推导式与集合辅助

通过结合集合和列表推导式，可以在保留顺序的同时高效去重。

```python

data = [1, 2, 2, 3, 4, 4, 5]

seen = set()

unique_data = [x for x in data if not (x in seen or seen.add(x))]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用Pandas的drop_duplicates方法

对于DataFrame数据，Pandas的drop_duplicates方法可以基于指定列或全部列去重。

```python

import pandas as pd

data = {'col1': [1, 2, 2, 3, 4, 4, 5]}

df = pd.DataFrame(data)

unique_df = df.drop_duplicates()

print(unique_df['col1'].tolist()) # 输出: [1, 2, 3, 4, 5]

```

### 使用NumPy的unique方法返回索引

NumPy的unique方法可以返回唯一值的索引，用于重构去重后的列表。

```python

import numpy as np

data = [1, 2, 2, 3, 4, 4, 5]

_, indices = np.unique(data, return_index=True)

unique_data = [data[i] for i in sorted(indices)]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表的count方法去重

通过统计元素出现次数，仅保留首次出现的元素，适用于小规模数据。

```python

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = [x for i, x in enumerate(data) if data.index(x) == i]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用Pandas的duplicated方法

Pandas的duplicated方法可以标记重复行，通过布尔索引过滤重复项。

```python

import pandas as pd

data = [1, 2, 2, 3, 4, 4, 5]

series = pd.Series(data)

unique_data = series[~series.duplicated()].tolist()

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表推导式与enumerate

结合enumerate和列表推导式，可以高效去重并保留顺序。

```python

data = [1, 2, 2, 3, 4, 4, 5]

seen = set()

unique_data = [x for i, x in enumerate(data) if x not in seen and not seen.add(x)]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用functools.reduce去重

通过reduce函数和条件判断，可以逐步构建去重后的列表。

```python

from functools import reduce

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = reduce(lambda acc, x: acc if x in acc else acc + [x], data, [])

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表的pop方法去重

通过遍历列表并移除重复项，适用于需要修改原列表的场景。

```python

data = [1, 2, 2, 3, 4, 4, 5]

i = 0

while i < len(data):

if data.count(data[i]) > 1:

data.pop(i)

else:

i += 1

print(data) # 输出: [1, 2, 3, 4, 5]

```

### 使用Pandas的groupby方法去重

对于DataFrame数据，可以使用groupby方法按指定列分组并去重。

```python

import pandas as pd

data = {'col1': [1, 2, 2, 3, 4, 4, 5]}

df = pd.DataFrame(data)

unique_df = df.groupby('col1').first().reset_index()

print(unique_df['col1'].tolist()) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表推导式与切片赋值

通过切片赋值直接修改原列表，适用于需要原地去重的场景。

```python

data = [1, 2, 2, 3, 4, 4, 5]

data[:] = [data[i] for i in range(len(data)) if data.index(data[i]) == i]

print(data) # 输出: [1, 2, 3, 4, 5]

```

### 使用NumPy的bincount方法去重

适用于非负整数数据，通过bincount统计出现次数并提取唯一值。

```python

import numpy as np

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = np.where(np.bincount(data))[0].tolist()

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表的reverse和pop方法去重

通过反转列表并移除重复项，再反转回原始顺序，适用于特定场景。

```python

data = [1, 2, 2, 3, 4, 4, 5]

data.reverse()

i = 0

while i < len(data):

if data.count(data[i]) > 1:

data.pop(i)

else:

i += 1

data.reverse()

print(data) # 输出: [1, 2, 3, 4, 5]

```

### 使用Pandas的value_counts方法去重

通过value_counts统计频次并提取索引，可以获取唯一值列表。

```python

import pandas as pd

data = [1, 2, 2, 3, 4, 4, 5]

series = pd.Series(data)

unique_data = series.value_counts().index.tolist()

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表推导式与any函数

通过any函数检查元素是否已存在，适用于小规模数据去重。

```python

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = []

[unique_data.append(x) for x in data if not any(y == x for y in unique_data)]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用NumPy的in1d方法去重

通过in1d方法标记唯一值，并结合布尔索引提取去重后的数据。

```python

import numpy as np

data = [1, 2, 2, 3, 4, 4, 5]

_, idx = np.unique(data, return_index=True)

unique_data = data[sorted(idx)]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表的sort和pop方法去重

通过排序后移除相邻重复项，适用于不要求保留原始顺序的场景。

```python

data = [1, 2, 2, 3, 4, 4, 5]

data.sort()

i = 0

while i < len(data) - 1:

if data[i] == data[i + 1]:

data.pop(i)

else:

i += 1

print(data) # 输出: [1, 2, 3, 4, 5]

```

### 使用Pandas的apply方法去重

对于复杂数据结构，可以使用apply方法结合自定义函数去重。

```python

import pandas as pd

data = [1, 2, 2, 3, 4, 4, 5]

df = pd.DataFrame(data, columns=['col1'])

unique_data = df['col1'].apply(lambda x: x).drop_duplicates().tolist()

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表推导式与zip函数

结合zip和列表推导式，可以高效去重并保留顺序。

```python

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = [x for i, x in enumerate(data) if data.index(x) == i]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用NumPy的argsort方法去重

通过argsort方法获取排序索引，并结合unique方法去重。

```python

import numpy as np

data = [1, 2, 2, 3, 4, 4, 5]

_, indices = np.unique(data, return_index=True)

unique_data = [data[i] for i in sorted(indices)]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表的remove方法去重

通过遍历列表并移除后续重复项，适用于需要修改原列表的场景。

```python

data = [1, 2, 2, 3, 4, 4, 5]

i = 0

while i < len(data):

j = i + 1

while j < len(data):

if data[i] == data[j]:

data.remove(data[j])

else:

j += 1

i += 1

print(data) # 输出: [1, 2, 3, 4, 5]

```

### 使用Pandas的nunique方法

nunique方法可以统计唯一值数量，结合其他方法可实现去重。

```python

import pandas as pd

data = [1, 2, 2, 3, 4, 4, 5]

series = pd.Series(data)

unique_count = series.nunique()

unique_data = series.drop_duplicates().tolist()

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表推导式与all函数

通过all函数检查元素是否唯一，适用于小规模数据去重。

```python

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = []

[unique_data.append(x) for x in data if all(y != x for y in unique_data)]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用NumPy的setdiff1d方法去重

通过setdiff1d方法查找差异元素，适用于特定去重场景。

```python

import numpy as np

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = np.setdiff1d(data, data, assume_unique=False).tolist()

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表的index和count方法去重

结合index和count方法，可以高效去重并保留顺序。

```python

data = [1, 2, 2, 3, 4, 4, 5]

unique_data = [x for i, x in enumerate(data) if data.index(x) == i and data.count(x) == 1]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用Pandas的drop_duplicates的keep参数

通过keep参数控制保留哪些重复项，适用于需要特定去重策略的场景。

```python

import pandas as pd

data = [1, 2, 2, 3, 4, 4, 5]

series = pd.Series(data)

unique_data = series.drop_duplicates(keep='first').tolist()

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表推导式与frozenset

通过frozenset的不可变性，可以在去重同时保留顺序。

```python

data = [1, 2, 2, 3, 4, 4, 5]

seen = set()

unique_data = [x for x in data if not (frozenset([x]) <= seen or seen.add(x))]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用NumPy的unique的return_counts参数

通过return_counts参数获取唯一值的频次，适用于需要统计信息的场景。

```python

import numpy as np

data = [1, 2, 2, 3, 4, 4, 5]

unique_values, counts = np.unique(data, return_counts=True)

unique_data = unique_values.tolist()

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表的copy方法去重

通过创建副本并修改原列表，适用于需要保留原数据的场景。

```python

data = [1, 2, 2, 3, 4, 4, 5]

temp = data.copy()

data.clear()

for x in temp:

if x not in data:

data.append(x)

print(data) # 输出: [1, 2, 3, 4, 5]

```

### 使用Pandas的duplicated的subset参数

对于多列数据，可以通过subset参数指定去重列。

```python

import pandas as pd

data = {'col1': [1, 2, 2, 3, 4, 4, 5], 'col2': ['a', 'b', 'b', 'c', 'd', 'd', 'e']}

df = pd.DataFrame(data)

unique_df = df.drop_duplicates(subset=['col1'])

print(unique_df['col1'].tolist()) # 输出: [1, 2, 3, 4, 5]

```

### 使用列表推导式与map函数

结合map函数和列表推导式，可以高效去重并保留顺序。

```python

data = [1, 2, 2, 3, 4, 4, 5]

seen = set()

unique_data = [x for x in data if x not in seen and not seen.add(x)]

print(unique_data) # 输出: [1, 2, 3, 4, 5]

```

### 使用NumPy的unique的return_inverse参数

通过return_inverse参数获取重构原始数组的